@datalayer/agent-runtimes 1.0.29 → 1.3.10

package/lib/loop/plugins/chat-view/index.js

@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * `@datalayer/loop-plugin-chat-view` — the bare conversation, one click away.
+ *
+ * The footer icon that clears the editor column: the view the selector used
+ * to call "None", renamed to what it actually is. Requires the input-prompt
+ * plugin, whose footer the icon sits in.
+ *
+ * @module loop/plugins/chat-view
+ */
+import { CommentDiscussionIcon } from '@primer/octicons-react';
+import { NONE_EDITOR } from '../shell/editorChoice';
+import { defineViewPlugin } from '../view-switch';
+export const CHAT_VIEW_PLUGIN_NAME = '@datalayer/loop-plugin-chat-view';
+export const ChatViewPlugin = defineViewPlugin({
+    key: 'chat',
+    viewId: NONE_EDITOR,
+    displayName: 'Chat view',
+    description: 'The conversation on its own, from the composer footer.',
+    icon: CommentDiscussionIcon,
+    tooltip: 'Show the chat',
+    octicon: 'comment-discussion',
+    emoji: '\u{1F4AC}',
+    order: 10,
+});
+export default ChatViewPlugin;

package/lib/loop/plugins/checkpoints-sidebar/CheckpointsSidebar.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The conversation checkpoints of the workspace's agent.
+ *
+ * Reads them from the server the workspace is backed by, again after every
+ * snapshot the agent pushes (so a turn's auto-checkpoint shows as the turn
+ * ends), and offers the three things a person does with them: save one now,
+ * rewind to one, drop one. A rewind asks the chat to reload its transcript
+ * once the server's fresh snapshot has arrived, so what is on screen is what
+ * the agent now remembers.
+ *
+ * @module loop/plugins/checkpoints-sidebar/CheckpointsSidebar
+ */
+import React from 'react';
+import type { LoopWorkspaceContext } from '../../core';
+/** "2 min ago" for a checkpoint's time, or the time itself when older. */
+export declare function ago(iso: string, now?: number): string;
+/**
+ * Wait for the store's full context to change — the server's next snapshot —
+ * then resolve; resolve anyway after `timeoutMs`.
+ */
+export declare function afterNextSnapshot(timeoutMs?: number): Promise<void>;
+export interface CheckpointsSidebarProps {
+    /** Forwarded by the shell: where the agent runs and which one it is. */
+    workspace?: LoopWorkspaceContext;
+}
+export declare function CheckpointsSidebar({ workspace, }: CheckpointsSidebarProps): React.ReactElement;
+export default CheckpointsSidebar;

package/lib/loop/plugins/checkpoints-sidebar/CheckpointsSidebar.js

@@ -0,0 +1,174 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * The conversation checkpoints of the workspace's agent.
+ *
+ * Reads them from the server the workspace is backed by, again after every
+ * snapshot the agent pushes (so a turn's auto-checkpoint shows as the turn
+ * ends), and offers the three things a person does with them: save one now,
+ * rewind to one, drop one. A rewind asks the chat to reload its transcript
+ * once the server's fresh snapshot has arrived, so what is on screen is what
+ * the agent now remembers.
+ *
+ * @module loop/plugins/checkpoints-sidebar/CheckpointsSidebar
+ */
+import { useCallback, useEffect, useMemo, useRef, useState, } from 'react';
+import { Button, Heading, IconButton, Label, Text, TextInput, Timeline, } from '@primer/react';
+import { BookmarkIcon, HistoryIcon, SyncIcon, TrashIcon, VersionsIcon, } from '@primer/octicons-react';
+import { Box } from '@datalayer/primer-addons';
+import { deleteConversationCheckpoint, isAutoCheckpoint, listConversationCheckpoints, rewindConversation, saveConversationCheckpoint, } from '../../../api/checkpoints';
+import { agentRuntimeStore, useAgentRuntimeStore, } from '../../../stores/agentRuntimeStore';
+/** How long to wait for the server's snapshot after a rewind before reloading anyway. */
+const SNAPSHOT_WAIT_MS = 3000;
+const FREQUENCY_LABEL = {
+    every_turn: 'after every turn',
+    every_tool: 'before every tool call',
+    manual_only: 'only on request',
+};
+/** "2 min ago" for a checkpoint's time, or the time itself when older. */
+export function ago(iso, now = Date.now()) {
+    const then = new Date(iso).getTime();
+    if (Number.isNaN(then))
+        return '';
+    const seconds = Math.max(0, Math.round((now - then) / 1000));
+    if (seconds < 45)
+        return 'just now';
+    const minutes = Math.round(seconds / 60);
+    if (minutes < 60)
+        return `${minutes} min ago`;
+    const hours = Math.round(minutes / 60);
+    if (hours < 24)
+        return `${hours} h ago`;
+    return new Date(then).toLocaleString();
+}
+/**
+ * Wait for the store's full context to change — the server's next snapshot —
+ * then resolve; resolve anyway after `timeoutMs`.
+ */
+export function afterNextSnapshot(timeoutMs = SNAPSHOT_WAIT_MS) {
+    return new Promise(resolve => {
+        const before = agentRuntimeStore.getState().fullContext;
+        let done = false;
+        const finish = () => {
+            if (done)
+                return;
+            done = true;
+            unsubscribe();
+            window.clearTimeout(timer);
+            resolve();
+        };
+        const unsubscribe = agentRuntimeStore.subscribe(state => state.fullContext, next => {
+            if (next !== before)
+                finish();
+        });
+        const timer = window.setTimeout(finish, timeoutMs);
+    });
+}
+function SectionHeading({ children }) {
+    return (_jsx(Heading, { as: "h4", sx: { fontSize: 1, mb: 2 }, children: children }));
+}
+export function CheckpointsSidebar({ workspace, }) {
+    const serverUrl = workspace?.serverUrl ?? '';
+    const agentId = workspace?.agentId ?? '';
+    const [state, setState] = useState(null);
+    const [error, setError] = useState(null);
+    const [busy, setBusy] = useState(null);
+    const [label, setLabel] = useState('');
+    const [now, setNow] = useState(() => Date.now());
+    // A new snapshot means a turn ended (or a rewind landed): read the list again.
+    const fullContext = useAgentRuntimeStore(s => s.fullContext);
+    const alive = useRef(true);
+    const reload = useCallback(async () => {
+        if (!serverUrl || !agentId)
+            return;
+        try {
+            const next = await listConversationCheckpoints(serverUrl, agentId);
+            if (!alive.current)
+                return;
+            setState(next);
+            setError(null);
+            setNow(Date.now());
+        }
+        catch (err) {
+            if (!alive.current)
+                return;
+            setError(err instanceof Error ? err.message : String(err));
+        }
+    }, [serverUrl, agentId]);
+    useEffect(() => {
+        alive.current = true;
+        return () => {
+            alive.current = false;
+        };
+    }, []);
+    useEffect(() => {
+        void reload();
+    }, [reload, fullContext]);
+    // The "ago" labels move on their own.
+    useEffect(() => {
+        const timer = window.setInterval(() => setNow(Date.now()), 30000);
+        return () => window.clearInterval(timer);
+    }, []);
+    const act = useCallback(async (key, work) => {
+        setBusy(key);
+        setError(null);
+        try {
+            await work();
+        }
+        catch (err) {
+            if (alive.current) {
+                setError(err instanceof Error ? err.message : String(err));
+            }
+        }
+        finally {
+            if (alive.current)
+                setBusy(null);
+        }
+        await reload();
+    }, [reload]);
+    const save = useCallback(() => {
+        const trimmed = label.trim();
+        if (!trimmed)
+            return;
+        void act('save', async () => {
+            await saveConversationCheckpoint(serverUrl, agentId, trimmed);
+            if (alive.current)
+                setLabel('');
+        });
+    }, [act, agentId, label, serverUrl]);
+    const rewind = useCallback((checkpoint) => act(`rewind:${checkpoint.id}`, async () => {
+        const settled = afterNextSnapshot();
+        await rewindConversation(serverUrl, agentId, checkpoint.id);
+        // The server pushes the rewound snapshot; ask for one too in case the
+        // push raced us, then have the chat load the transcript it now has.
+        agentRuntimeStore.getState().requestRefresh(agentId);
+        await settled;
+        agentRuntimeStore.getState().requestHistoryReload();
+    }), [act, agentId, serverUrl]);
+    const remove = useCallback((checkpoint) => act(`delete:${checkpoint.id}`, () => deleteConversationCheckpoint(serverUrl, agentId, checkpoint.id)), [act, agentId, serverUrl]);
+    const checkpoints = useMemo(() => state?.checkpoints ?? [], [state]);
+    const enabled = state?.enabled ?? false;
+    return (_jsxs(Box, { "data-checkpoints-sidebar": agentId || undefined, "data-checkpoints-count": checkpoints.length, sx: { display: 'flex', flexDirection: 'column', gap: 4 }, children: [_jsxs(Box, { sx: { display: 'flex', alignItems: 'center', gap: 2 }, children: [_jsx(VersionsIcon, { size: 16 }), _jsx(Heading, { as: "h3", sx: { fontSize: 2, m: 0, flex: 1 }, children: "Checkpoints" }), _jsx(Label, { variant: "accent", children: checkpoints.length }), _jsx(IconButton, { icon: SyncIcon, size: "small", variant: "invisible", "aria-label": "Refresh checkpoints", onClick: () => void reload() })] }), _jsxs(Box, { children: [_jsx(SectionHeading, { children: "How they are taken" }), state === null ? (_jsx(Text, { sx: { fontSize: 0, color: 'fg.muted' }, children: error ? `Could not read them: ${error}` : 'Reading…' })) : !enabled ? (_jsx(Text, { as: "p", sx: { fontSize: 0, color: 'fg.muted', m: 0 }, children: "This agent's spec asks for no conversation checkpoints." })) : (_jsxs(Box, { sx: {
+                            display: 'grid',
+                            gridTemplateColumns: 'max-content 1fr',
+                            columnGap: 3,
+                            rowGap: 1,
+                            fontSize: 0,
+                        }, children: [_jsx(Text, { sx: { color: 'fg.muted' }, children: "Snapshot" }), _jsx(Text, { children: FREQUENCY_LABEL[state.frequency ?? ''] ?? state.frequency }), _jsx(Text, { sx: { color: 'fg.muted' }, children: "Kept" }), _jsxs(Text, { children: ["the last ", state.maxCheckpoints ?? '—', ",", ' ', state.store ?? 'in_memory'] }), _jsx(Text, { sx: { color: 'fg.muted' }, children: "Turn" }), _jsx(Text, { "data-checkpoints-turn": state.turn, children: state.turn })] }))] }), enabled ? (_jsxs(Box, { children: [_jsx(SectionHeading, { children: "Save one now" }), _jsxs(Box, { sx: { display: 'flex', gap: 2 }, children: [_jsx(TextInput, { size: "small", sx: { flex: 1 }, placeholder: "Label, e.g. before-refactor", value: label, "aria-label": "Checkpoint label", onChange: event => setLabel(event.target.value), onKeyDown: event => {
+                                    if (event.key === 'Enter')
+                                        save();
+                                } }), _jsx(Button, { size: "small", leadingVisual: BookmarkIcon, disabled: !label.trim() || busy !== null, onClick: save, "data-checkpoints-save": true, children: "Save" })] }), _jsx(Text, { as: "p", sx: { fontSize: 0, color: 'fg.muted', mt: 1, mb: 0 }, children: "The conversation as the last turn left it." })] })) : null, error && state !== null ? (_jsx(Text, { sx: { fontSize: 0, color: 'danger.fg' }, "data-checkpoints-error": true, children: error })) : null, _jsxs(Box, { children: [_jsx(SectionHeading, { children: "Checkpoints" }), checkpoints.length === 0 ? (_jsx(Text, { as: "p", sx: { fontSize: 0, color: 'fg.muted', m: 0 }, children: enabled ? 'None yet — one is taken as each turn ends.' : 'None.' })) : (_jsx(Timeline, { children: checkpoints.map(checkpoint => {
+                            const auto = isAutoCheckpoint(checkpoint);
+                            const rewinding = busy === `rewind:${checkpoint.id}`;
+                            return (_jsxs(Timeline.Item, { "data-checkpoint": checkpoint.id, "data-checkpoint-label": checkpoint.label, "data-checkpoint-auto": auto ? 'true' : 'false', children: [_jsx(Timeline.Badge, { children: auto ? _jsx(HistoryIcon, {}) : _jsx(BookmarkIcon, {}) }), _jsxs(Timeline.Body, { children: [_jsxs(Box, { sx: {
+                                                    display: 'flex',
+                                                    alignItems: 'center',
+                                                    gap: 2,
+                                                    flexWrap: 'wrap',
+                                                }, children: [_jsx(Text, { sx: { fontWeight: 'bold', fontSize: 1 }, children: checkpoint.label }), _jsx(Label, { size: "small", variant: auto ? 'secondary' : 'accent', children: auto ? 'auto' : 'saved' })] }), _jsxs(Text, { as: "p", sx: { fontSize: 0, color: 'fg.muted', mt: 0, mb: 1 }, children: ["turn ", checkpoint.turn, " \u00B7 ", checkpoint.messageCount, " message", checkpoint.messageCount === 1 ? '' : 's', " \u00B7", ' ', ago(checkpoint.createdAt, now)] }), _jsxs(Box, { sx: { display: 'flex', gap: 2, alignItems: 'center' }, children: [_jsx(Button, { size: "small", leadingVisual: HistoryIcon, disabled: busy !== null, onClick: () => void rewind(checkpoint), "data-checkpoints-rewind": checkpoint.id, children: rewinding ? 'Rewinding…' : 'Rewind' }), _jsx(IconButton, { icon: TrashIcon, size: "small", variant: "invisible", "aria-label": `Delete checkpoint ${checkpoint.label}`, disabled: busy !== null, onClick: () => void remove(checkpoint) })] })] })] }, checkpoint.id));
+                        }) }))] })] }));
+}
+export default CheckpointsSidebar;

package/lib/loop/plugins/checkpoints-sidebar/index.d.ts

@@ -0,0 +1,5 @@
+import type { ReactorReactOutput } from '@datalayer/reactor/react';
+export declare const CHECKPOINTS_SIDEBAR_PLUGIN_NAME = "@datalayer/loop-plugin-checkpoints-sidebar";
+export declare const CheckpointsSidebarPlugin: import("@datalayer/reactor").ReactorPlugin<Record<string, never>, unknown, ReactorReactOutput>;
+export { CheckpointsSidebar } from './CheckpointsSidebar';
+export default CheckpointsSidebarPlugin;

package/lib/loop/plugins/checkpoints-sidebar/index.js

@@ -0,0 +1,39 @@
+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-checkpoints-sidebar` — the agent's conversation
+ * checkpoints, at the side of the workspace.
+ *
+ * The agent snapshots its conversation as it runs; this lists the snapshots
+ * with how they were taken, lets a person save one between turns, rewind
+ * the conversation to one — the chat reloads its transcript — and drop one.
+ *
+ * @module loop/plugins/checkpoints-sidebar
+ */
+import { definePlugin } from '@datalayer/reactor';
+import { LoopSlots } from '../../core';
+import { CheckpointsSidebar } from './CheckpointsSidebar';
+export const CHECKPOINTS_SIDEBAR_PLUGIN_NAME = '@datalayer/loop-plugin-checkpoints-sidebar';
+export const CheckpointsSidebarPlugin = definePlugin({
+    name: CHECKPOINTS_SIDEBAR_PLUGIN_NAME,
+    displayName: 'Checkpoints sidebar',
+    description: 'The conversation checkpoints, and the way back to any of them.',
+    octicon: 'versions',
+    emoji: '\u{1F4BE}',
+    build: () => ({
+        components: [
+            {
+                id: 'checkpoints-sidebar',
+                slot: LoopSlots.sidebar,
+                // Part of the work, so above the plugins panel (900).
+                order: 100,
+                Component: ({ workspace }) => (_jsx(CheckpointsSidebar, { workspace: workspace })),
+            },
+        ],
+    }),
+});
+export { CheckpointsSidebar } from './CheckpointsSidebar';
+export default CheckpointsSidebarPlugin;

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

@@ -0,0 +1,20 @@
+import type { Contribution } from '@datalayer/reactor';
+import type { ReactorReactOutput } from '@datalayer/reactor/react';
+import { type CommandContribution, type LoopWorkspaceContext } from '../../core';
+export declare const COMMANDS_PLUGIN_NAME = "@datalayer/loop-plugin-commands";
+export type LoopCommandBridgeProps = {
+    /** Handed by the slot; the commands run against it. */
+    workspace?: LoopWorkspaceContext;
+    /** Registers the current set, and returns what undoes it. */
+    sync: (commands: Contribution<CommandContribution>[], workspace: LoopWorkspaceContext | undefined) => void;
+};
+/**
+ * Renders nothing; keeps the registry in step with the contributions.
+ *
+ * A component rather than a one-off registration in `register`, because
+ * contributions arrive as plugins activate — a plugin switched on from the
+ * sidebar has to show up in the palette without a reload.
+ */
+export declare function LoopCommandBridge({ workspace, sync, }: LoopCommandBridgeProps): null;
+export declare const LoopCommandsPlugin: import("@datalayer/reactor").ReactorPlugin<Record<string, never>, unknown, ReactorReactOutput>;
+export default LoopCommandsPlugin;

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

@@ -0,0 +1,148 @@
+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-commands` — the workspace's commands, in the palette.
+ *
+ * A thin adapter over the reusable `@datalayer/reactor-commands`: that plugin
+ * draws a Ctrl-K palette over the reactor's command registry and knows nothing
+ * about a workspace, and this one puts the workspace's commands into that
+ * registry. Keeping them apart is what lets the palette stay generic — it is
+ * the same palette in a music store and in an agent workspace.
+ *
+ * Every command a plugin already contributes to {@link LoopCommand} appears,
+ * rather than each plugin declaring its actions twice. A slash command and a
+ * palette entry are the same intent reached two ways, and a plugin that wrote
+ * them separately would eventually have them disagree — a `/models` that shows
+ * something the palette's *Show the models* does not.
+ *
+ * What it cannot do from a plugin phase is know which workspace is on screen,
+ * because that is built during render. So the registration is driven by a
+ * component: it reads the contributions and the workspace it was handed, and
+ * re-registers when either changes.
+ *
+ * @module loop/plugins/commands
+ */
+import { useEffect } from 'react';
+import { definePlugin } from '@datalayer/reactor';
+import { useContributions } from '@datalayer/reactor/react';
+import { CommandsPlugin } from '@datalayer/reactor-commands';
+import { ThemePlugin } from '@datalayer/primer-addons/lib/reactor';
+import { LoopCommand, LoopSlots, } from '../../core';
+export const COMMANDS_PLUGIN_NAME = '@datalayer/loop-plugin-commands';
+/** How a slash command's group becomes a palette category. */
+const DEFAULT_CATEGORY = 'Workspace';
+/**
+ * Emoji per group, so the palette has something to show for commands that
+ * predate it. A slash command never needed one — `/help` prints text — and
+ * backfilling a field onto every contribution to satisfy a surface added
+ * later is how a shared type acquires a column that means "for the palette".
+ */
+const GROUP_EMOJI = {
+    Agents: '\u{1F916}',
+    Open: '\u{1F4C2}',
+    Session: '\u{1F9ED}',
+    Workspace: '\u{1FA9F}',
+};
+/**
+ * Renders nothing; keeps the registry in step with the contributions.
+ *
+ * A component rather than a one-off registration in `register`, because
+ * contributions arrive as plugins activate — a plugin switched on from the
+ * sidebar has to show up in the palette without a reload.
+ */
+export function LoopCommandBridge({ workspace, sync, }) {
+    const commands = useContributions(LoopCommand);
+    useEffect(() => {
+        sync(commands, workspace);
+    }, [commands, workspace, sync]);
+    return null;
+}
+export const LoopCommandsPlugin = definePlugin({
+    name: COMMANDS_PLUGIN_NAME,
+    displayName: 'Command palette',
+    description: 'Puts the workspace commands in a Ctrl-K palette, beside every plugin that registers one.',
+    octicon: 'command-palette',
+    emoji: '\u{2318}',
+    // The generic palette is pulled in rather than assumed: mounting this one is
+    // enough, whether or not the host remembered the other. The theme plugin
+    // rides along for the same reason: it is what creates the themed portal
+    // root the palette renders into — and keeps its color mode following the
+    // application, which the old inline `setupPrimerPortals()` call never did.
+    dependencies: [CommandsPlugin, ThemePlugin],
+    build: ctx => {
+        /** What each contribution's registration undoes, by command name. */
+        const registered = new Map();
+        /*
+         * What was registered last time, so an unchanged set is left alone.
+         *
+         * Registering and disposing both move the reactor's revision, and the
+         * revision is what `useContributions` re-reads on — so a sync that always
+         * re-registers wakes the component that called it, which syncs again, for
+         * ever. React reports it as "Maximum update depth exceeded", several frames
+         * away from the cause.
+         */
+        let signature = '';
+        let lastWorkspace;
+        const sync = (commands, workspace) => {
+            const next = workspace
+                ? commands.map(entry => `${entry.plugin}:${entry.value.name}`).join('|')
+                : '';
+            if (next === signature && workspace === lastWorkspace) {
+                return;
+            }
+            signature = next;
+            lastWorkspace = workspace;
+            // Re-registered wholesale rather than diffed: the palette has to invoke
+            // against the *current* workspace, so a command registered against a
+            // previous one is wrong even when its contribution has not changed.
+            for (const dispose of registered.values()) {
+                dispose();
+            }
+            registered.clear();
+            if (!workspace) {
+                // Nothing to run against. Registering commands that would throw the
+                // moment they are chosen is worse than an empty palette.
+                return;
+            }
+            for (const entry of commands) {
+                const command = entry.value;
+                const group = command.group ?? DEFAULT_CATEGORY;
+                registered.set(command.name, ctx.registerCommand({
+                    // Namespaced, because a palette is shared with every other plugin
+                    // and `chat` is not a name anyone else has to avoid.
+                    id: `loop.${command.name}`,
+                    name: command.description,
+                    // The slash form is what a person may already know it by, so it is
+                    // worth showing beside the description rather than instead of it.
+                    description: `/${command.name}`,
+                    emoji: GROUP_EMOJI[group] ?? '\u{1F4A0}',
+                    category: group,
+                    // Carried through rather than invented here: a shortcut belongs to
+                    // the plugin that knows what the command does.
+                    keybinding: command.keybinding,
+                    // Slash commands take their arguments as text after the name; the
+                    // palette has no argument to give, so they run with none. A command
+                    // that needs one says so when it runs.
+                    execute: async () => {
+                        await command.run({ workspace, argv: '' });
+                    },
+                }));
+            }
+        };
+        return {
+            components: [
+                {
+                    id: 'loop-command-bridge',
+                    // Rendered where the workspace already passes itself down, and
+                    // invisible: the palette is the surface, this only feeds it.
+                    slot: LoopSlots.status,
+                    Component: ({ workspace }) => (_jsx(LoopCommandBridge, { workspace: workspace, sync: sync })),
+                },
+            ],
+        };
+    },
+});
+export default LoopCommandsPlugin;

package/lib/loop/plugins/decks/DeckSurface.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The deck beside the chat: the decks plugin's own view, in the editor column.
+ *
+ * It shows whichever deck the store says is open — the agent's `decks_open`,
+ * a click in the sidebar list, the composer menu — and an invitation to make
+ * one when none is.
+ */
+import type { JSX } from 'react';
+import type { ChatSurfaceProps } from '../../core';
+export default function DeckSurface(_: ChatSurfaceProps): JSX.Element;

package/lib/loop/plugins/decks/DeckSurface.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Box } from '@primer/react';
+import { DecksView } from '@datalayer/decks/plugin';
+export default function DeckSurface(_) {
+    return (_jsx(Box, { sx: { height: '100%', minHeight: 0, overflow: 'auto' }, children: _jsx(DecksView, {}) }));
+}

package/lib/loop/plugins/decks/DecksMenu.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The decks menu in the composer's action row.
+ *
+ * One icon beside the prompt: the decks the catalog knows, to open one, and
+ * the plugin's commands — the same ones the palette lists and the agent
+ * calls — with their keystrokes. Read from the reactor rather than written
+ * out here, so a command the plugin adds is in the menu without this file
+ * changing.
+ */
+import type { JSX } from 'react';
+export default function DecksMenu(): JSX.Element | null;

package/lib/loop/plugins/decks/DecksMenu.js

@@ -0,0 +1,42 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { ActionList, ActionMenu, IconButton } from '@primer/react';
+// A stack of slides — not the project icon, which the Deck view button
+// beside this menu already wears.
+import { StackIcon } from '@primer/octicons-react';
+import { useReactorPlatform } from '@datalayer/reactor/react';
+import { deckId } from '@datalayer/decks';
+import { openDeck, useDeckEntries, useDecksState, } from '@datalayer/decks/plugin';
+import { chooseEditor } from '../shell/editorChoice';
+import { DECK_SURFACE_ID } from './surface';
+/** Commands that take an argument; a menu row cannot supply one. */
+const NEEDS_ARGUMENT = new Set(['decks.open', 'decks.goToSlide']);
+export default function DecksMenu() {
+    const reactor = useReactorPlatform();
+    const decks = useDeckEntries();
+    const { selected } = useDecksState();
+    const commands = reactor
+        .listCommands()
+        .filter(command => command.category === 'Decks' && !NEEDS_ARGUMENT.has(command.id));
+    if (commands.length === 0 && decks.length === 0) {
+        return null;
+    }
+    const show = () => {
+        if (!chooseEditor(DECK_SURFACE_ID)) {
+            console.warn('[loop] No chat is on screen to show the deck beside.');
+        }
+    };
+    return (_jsxs(ActionMenu, { children: [_jsx(ActionMenu.Anchor, { children: _jsx(IconButton, { icon: StackIcon, "aria-label": "Decks", size: "small", variant: "invisible" }) }), _jsx(ActionMenu.Overlay, { width: "medium", children: _jsxs(ActionList, { children: [decks.length > 0 ? (_jsxs(ActionList.Group, { children: [_jsx(ActionList.GroupHeading, { children: "Open a deck" }), decks.map(entry => {
+                                    const id = deckId(entry);
+                                    return (_jsxs(ActionList.Item, { selected: id === selected, onSelect: () => {
+                                            openDeck(id);
+                                            show();
+                                        }, children: [entry.spec.deck.title, _jsxs(ActionList.Description, { variant: "block", children: [id, " \u00B7 ", entry.spec.slides.length, " slides"] })] }, id));
+                                })] })) : null, decks.length > 0 && commands.length > 0 ? (_jsx(ActionList.Divider, {})) : null, commands.length > 0 ? (_jsxs(ActionList.Group, { children: [_jsx(ActionList.GroupHeading, { children: "Commands" }), commands.map(command => (_jsxs(ActionList.Item, { onSelect: () => {
+                                        void reactor.executeCommand(command.id).then(() => {
+                                            // A command that changes what is on the deck wants the
+                                            // deck on screen; the list command shows the empty
+                                            // state there too, beside the sidebar's list.
+                                            show();
+                                        });
+                                    }, children: [command.name, command.description ? (_jsx(ActionList.Description, { variant: "block", children: command.description })) : null, command.keybinding ? (_jsx(ActionList.TrailingVisual, { children: command.keybinding })) : null] }, command.id)))] })) : null] }) })] }));
+}

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

@@ -0,0 +1,19 @@
+import type { ReactorReactOutput } from '@datalayer/reactor/react';
+export { DECK_SURFACE_ID } from './surface';
+export declare const DECKS_PLUGIN_NAME = "@datalayer/loop-plugin-decks";
+/**
+ * A slot nobody renders: the decks plugin's main view is shown through the
+ * Deck surface instead, so the plugin's own `slot` output must land nowhere.
+ */
+export declare const DECKS_UNUSED_SLOT = "loop.decks.unused";
+export declare const LoopDecksPlugin: import("@datalayer/reactor").ReactorPlugin<Record<string, never>, unknown, ReactorReactOutput>;
+/** The footer icon that shows the deck, beside the notebook's and the document's. */
+export declare const DeckViewPlugin: import("@datalayer/reactor").ReactorPlugin<Record<string, never>, unknown, {
+    components: {
+        id: string;
+        slot: "loop.promptAction";
+        order: number;
+        Component: () => import("react").JSX.Element | null;
+    }[];
+}>;
+export default LoopDecksPlugin;