@datalayer/agent-runtimes 1.0.9 → 1.0.17

package/lib/components/scheduler/ScheduleMenu.js

@@ -0,0 +1,154 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { useEffect, useMemo, useState } from 'react';
+import { ActionList, ActionMenu, Box, Button, Dialog, FormControl, IconButton, Spinner, Text, TextInput, } from '@primer/react';
+import { ClockIcon, TrashIcon } from '@primer/octicons-react';
+import { disableSchedule, updateSchedule, upsertSchedule, } from '../../api/scheduler/schedules';
+import { DEFAULT_SERVICE_URLS } from '@datalayer/core/lib/api/constants';
+const SCHEDULE_PRESETS = [
+    { id: 'every-minute', label: 'Every minute', cron: '* * * * *' },
+    { id: 'hourly', label: 'Every hour', cron: '0 * * * *' },
+    { id: 'daily', label: 'Every day', cron: '0 0 * * *' },
+];
+const DEFAULT_CRON_EXPRESSION = '* * * * *';
+const presetFromCron = (cronExpression) => {
+    const normalized = cronExpression.trim();
+    const preset = SCHEDULE_PRESETS.find(item => item.cron === normalized);
+    return preset ? preset.id : 'custom';
+};
+/**
+ * Self-contained schedule menu that lets a user pick a cron schedule for a
+ * notebook and persists it to the scheduler service.
+ *
+ * The component owns its loading state and renders a spinner in place of the
+ * anchor icon while a save request is in flight. The scheduler service URL is
+ * configurable through the `baseUrl` prop.
+ */
+export const ScheduleMenu = ({ notebookUid, scheduleUid, token, baseUrl = DEFAULT_SERVICE_URLS.SCHEDULER, enabled, icon = ClockIcon, iconColor, ariaLabel = 'Schedule execution', initialPreset = 'every-minute', initialCronExpression, onSaved, onDeleted, onError, }) => {
+    const providedInitialCron = (initialCronExpression || '').trim();
+    const hasProvidedInitialCron = providedInitialCron.length > 0;
+    const initialCron = hasProvidedInitialCron
+        ? providedInitialCron
+        : DEFAULT_CRON_EXPRESSION;
+    const [cronExpression, setCronExpression] = useState(initialCron);
+    const [hasExplicitCron, setHasExplicitCron] = useState(hasProvidedInitialCron);
+    const [isSaving, setIsSaving] = useState(false);
+    const [isDeleting, setIsDeleting] = useState(false);
+    const [isDeleteDialogOpen, setIsDeleteDialogOpen] = useState(false);
+    const [deleteConfirmUid, setDeleteConfirmUid] = useState('');
+    useEffect(() => {
+        const nextProvidedCron = (initialCronExpression || '').trim();
+        const nextHasExplicitCron = nextProvidedCron.length > 0;
+        setHasExplicitCron(nextHasExplicitCron);
+        setCronExpression(nextHasExplicitCron ? nextProvidedCron : DEFAULT_CRON_EXPRESSION);
+    }, [initialCronExpression, scheduleUid, notebookUid]);
+    const preset = useMemo(() => (hasExplicitCron ? presetFromCron(cronExpression) : 'custom'), [cronExpression, hasExplicitCron]);
+    const isEnabled = (enabled ?? true) &&
+        Boolean(token) &&
+        Boolean(notebookUid || scheduleUid) &&
+        !isSaving &&
+        !isDeleting;
+    const selectedPresetDescription = useMemo(() => {
+        if (!hasExplicitCron) {
+            return 'Not scheduled';
+        }
+        const selected = SCHEDULE_PRESETS.find(item => item.cron === cronExpression.trim());
+        if (selected) {
+            return `${selected.label} (${selected.cron})`;
+        }
+        return `Custom (${cronExpression || 'Cron expression not set'})`;
+    }, [cronExpression, hasExplicitCron]);
+    const saveSchedule = async (nextPreset, nextCron) => {
+        const cron = nextCron.trim();
+        if (!token || (!notebookUid && !scheduleUid) || !cron) {
+            return;
+        }
+        setIsSaving(true);
+        try {
+            let schedule;
+            if (scheduleUid) {
+                const response = await updateSchedule(token, scheduleUid, {
+                    cronExpression: cron,
+                    preset: nextPreset,
+                }, baseUrl);
+                schedule = response.schedule;
+            }
+            else {
+                const response = await upsertSchedule(token, {
+                    notebookUid: notebookUid,
+                    cronExpression: cron,
+                    preset: nextPreset,
+                    enabled: true,
+                }, baseUrl);
+                schedule = response.schedule;
+            }
+            onSaved?.(schedule);
+        }
+        catch (error) {
+            onError?.(error);
+        }
+        finally {
+            setIsSaving(false);
+        }
+    };
+    const selectPreset = (nextPreset) => {
+        const next = SCHEDULE_PRESETS.find(item => item.id === nextPreset);
+        if (!next) {
+            return;
+        }
+        setHasExplicitCron(true);
+        setCronExpression(next.cron);
+        void saveSchedule(nextPreset, next.cron);
+    };
+    const applyCustomCron = () => {
+        const value = cronExpression.trim();
+        const inferredPreset = presetFromCron(value);
+        void saveSchedule(inferredPreset, value);
+    };
+    const performDeleteSchedule = async () => {
+        if (!token || !scheduleUid) {
+            return;
+        }
+        setIsDeleting(true);
+        try {
+            const response = await disableSchedule(token, scheduleUid, baseUrl);
+            setIsDeleteDialogOpen(false);
+            setDeleteConfirmUid('');
+            onDeleted?.(response.schedule);
+        }
+        catch (error) {
+            onError?.(error);
+        }
+        finally {
+            setIsDeleting(false);
+        }
+    };
+    return (_jsxs(_Fragment, { children: [_jsxs(ActionMenu, { children: [_jsx(ActionMenu.Anchor, { children: _jsx(IconButton, { icon: isSaving ? () => _jsx(Spinner, { size: "small" }) : icon, variant: "invisible", sx: iconColor ? { color: iconColor } : undefined, "aria-label": ariaLabel, title: isSaving
+                                ? `${ariaLabel} (saving…)`
+                                : isEnabled
+                                    ? ariaLabel
+                                    : `${ariaLabel} (disabled)` }) }), _jsxs(ActionMenu.Overlay, { width: "medium", sx: { minWidth: 300 }, children: [_jsx(Box, { sx: {
+                                    px: 3,
+                                    pt: 3,
+                                    pb: 2,
+                                    borderBottom: '1px solid',
+                                    borderColor: 'border.default',
+                                }, children: _jsx(Text, { as: "p", sx: { fontWeight: 600 }, children: "Schedule" }) }), _jsx(ActionList, { selectionVariant: "single", showDividers: true, children: SCHEDULE_PRESETS.map(option => (_jsxs(ActionList.Item, { selected: preset === option.id, disabled: !isEnabled, onSelect: () => selectPreset(option.id), children: [option.label, _jsx(ActionList.Description, { variant: "block", children: option.cron })] }, option.id))) }), _jsxs(Box, { sx: { p: 3, borderTop: '1px solid', borderColor: 'border.default' }, children: [_jsx(Text, { as: "p", sx: { fontSize: 0, color: 'fg.muted', mb: 2 }, children: "Cron Expression" }), _jsx(TextInput, { value: cronExpression, onChange: event => {
+                                            const value = event.currentTarget.value;
+                                            setHasExplicitCron(value.trim().length > 0);
+                                            setCronExpression(value);
+                                        }, placeholder: "* * * * *", "aria-label": "Cron expression", block: true, disabled: !isEnabled }), _jsxs(Box, { sx: { mt: 2, display: 'flex', gap: 2, flexWrap: 'wrap' }, children: [_jsx(Button, { size: "small", onClick: applyCustomCron, disabled: !isEnabled, children: "Apply Cron" }), scheduleUid ? (_jsx(Button, { size: "small", variant: "danger", leadingVisual: TrashIcon, onClick: () => setIsDeleteDialogOpen(true), disabled: !isEnabled, children: "Delete Schedule" })) : null] }), _jsxs(Text, { as: "p", sx: { mt: 2, fontSize: 0, color: 'fg.muted' }, children: ["Current: ", selectedPresetDescription] })] })] })] }), isDeleteDialogOpen && scheduleUid ? (_jsx(Dialog, { title: "Delete schedule", onClose: () => {
+                    if (isDeleting) {
+                        return;
+                    }
+                    setIsDeleteDialogOpen(false);
+                    setDeleteConfirmUid('');
+                }, width: "medium", children: _jsxs(Box, { sx: { display: 'grid', gap: 3 }, children: [_jsxs(Text, { children: ["This action will disable the schedule and remove planned runs. Type", ' ', _jsx(Text, { as: "span", sx: { fontWeight: 700 }, children: scheduleUid }), ' ', "to confirm."] }), _jsxs(FormControl, { children: [_jsx(FormControl.Label, { children: "Schedule UID" }), _jsx(TextInput, { value: deleteConfirmUid, onChange: event => setDeleteConfirmUid(event.currentTarget.value), placeholder: scheduleUid, autoFocus: true })] }), _jsxs(Box, { sx: { display: 'flex', justifyContent: 'flex-end', gap: 2 }, children: [_jsx(Button, { variant: "default", onClick: () => {
+                                        setIsDeleteDialogOpen(false);
+                                        setDeleteConfirmUid('');
+                                    }, disabled: isDeleting, children: "Cancel" }), _jsx(Button, { variant: "danger", onClick: () => void performDeleteSchedule(), disabled: isDeleting || deleteConfirmUid !== scheduleUid, children: "Delete schedule" })] })] }) })) : null] }));
+};
+export default ScheduleMenu;

package/lib/components/scheduler/index.d.ts

@@ -0,0 +1 @@
+export * from './ScheduleMenu';

package/lib/components/scheduler/index.js

@@ -0,0 +1,5 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+export * from './ScheduleMenu';

package/lib/components/snapshots/SandboxSnapshotMenu.d.ts

@@ -0,0 +1,33 @@
+import { type PropsWithChildren } from 'react';
+import { Kernel } from '@jupyterlab/services';
+import { IMultiServiceManager } from '../../runtimes';
+/**
+ * Code Sandbox snapshot menu component properties
+ */
+type ICodeSandboxSnapshotMenu = {
+    /**
+     * Application multi service manager.
+     */
+    multiServiceManager?: IMultiServiceManager;
+    /**
+     * Connection to the current kernel.
+     *
+     * It is needed only for browser kernels.
+     */
+    connection?: Kernel.IKernelConnection;
+    /**
+     * Pod name
+     *
+     * It is needed for remote kernels.
+     */
+    podName?: string;
+    /**
+     * Whether the menu is disabled.
+     */
+    disabled: boolean;
+};
+/**
+ * Code Sandbox Snapshot menu component.
+ */
+export declare function SandboxSnapshotMenu({ children, connection, podName, multiServiceManager, disabled, }: PropsWithChildren<ICodeSandboxSnapshotMenu>): JSX.Element;
+export {};

package/lib/components/snapshots/SandboxSnapshotMenu.js

@@ -0,0 +1,169 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { useCallback, useEffect, useState, } from 'react';
+import { DeviceCameraIcon } from '@primer/octicons-react';
+import { ActionList, ActionMenu, Flash, FormControl, Select, Spinner, } from '@primer/react';
+import { Dialog } from '@primer/react/experimental';
+import { Box } from '@datalayer/primer-addons';
+import { useToast } from '@datalayer/core/lib/hooks';
+import { createSandboxSnapshot, getSandboxSnapshots, loadBrowserSandboxSnapshot, loadSandboxSnapshot, } from '../../runtimes';
+import { useRuntimesStore } from '../../state/substates';
+import { createSandboxSnapshotName } from '@datalayer/core/lib/utils';
+/**
+ * Code Sandbox Snapshot menu component.
+ */
+export function SandboxSnapshotMenu({ children, connection, podName, multiServiceManager, disabled = false, }) {
+    const { addSandboxSnapshot, runtimesUrl, runtimeSnapshots, setSandboxSnapshots, } = useRuntimesStore();
+    const { enqueueToast, trackAsyncTask } = useToast();
+    const [openLoadDialog, setOpenLoadDialog] = useState(false);
+    const [loadingSandboxSnapshot, setLoadingSandboxSnapshot] = useState(false);
+    const [takingSandboxSnapshot, setTakingSandboxSnapshot] = useState(false);
+    const [selection, setSelection] = useState(runtimeSnapshots[0]?.id ?? '');
+    const [error, setError] = useState();
+    useEffect(() => {
+        getSandboxSnapshots()
+            .then(snapshots => {
+            setSandboxSnapshots(snapshots);
+            if (!selection && snapshots.length > 0) {
+                setSelection(snapshots[0].id);
+            }
+        })
+            .catch(reason => {
+            console.error(`Failed to fetch remote kernel snapshots; ${reason}`);
+        });
+    }, [runtimesUrl]);
+    const onLoadSandboxSnapshot = useCallback(() => {
+        setError(undefined);
+        setOpenLoadDialog(true);
+    }, []);
+    const onSandboxSnapshotChanged = useCallback(event => {
+        setSelection(event.target.value);
+    }, []);
+    const onLoadSandboxSnapshotSubmit = useCallback(async ({ id, connection, podName, }) => {
+        if (podName) {
+            await loadSandboxSnapshot({ id: podName, from: id });
+            enqueueToast(`Code Sandbox snapshot ${podName} is loaded.`, {
+                variant: 'success',
+            });
+        }
+        else if (connection) {
+            await loadBrowserSandboxSnapshot({ connection, id });
+            enqueueToast(`Code Sandbox snapshot ${id} is loaded.`, {
+                variant: 'success',
+            });
+        }
+    }, []);
+    const onTakeSandboxSnapshot = useCallback(async () => {
+        try {
+            setTakingSandboxSnapshot(true);
+            let snapshot;
+            let task;
+            let ref = '';
+            let snapshotName = '';
+            if (podName && multiServiceManager?.remote) {
+                snapshotName = createSandboxSnapshotName('cloud');
+                task = multiServiceManager.remote.runtimesManager.snapshotRuntime({
+                    podName,
+                    name: snapshotName,
+                    description: snapshotName,
+                    stop: false,
+                });
+                ref = podName.split('-', 2).reverse()[0];
+                task.then(s => {
+                    snapshot = s;
+                });
+            }
+            else if (connection && multiServiceManager?.browser) {
+                const model = connection.model;
+                ref = model.id;
+                snapshotName = createSandboxSnapshotName('browser');
+                let isPending = true;
+                task = createSandboxSnapshot({
+                    connection: multiServiceManager.browser.kernels.connectTo({
+                        model,
+                    }),
+                    metadata: { filename: `${snapshotName}.data` },
+                    onUploadProgress: () => {
+                        if (isPending) {
+                            isPending = false;
+                            // Get the kernel snapshot uid.
+                            getSandboxSnapshots().then(snapshots => {
+                                snapshot = snapshots.find(s => s.name === snapshotName);
+                            });
+                        }
+                    },
+                });
+            }
+            if (task) {
+                trackAsyncTask(task, {
+                    error: {
+                        message: (reason, data) => {
+                            const msg = reason === 'Empty snapshot'
+                                ? `Runtime ${ref} will not be snapshotted as it does not contain any serializable state.`
+                                : `Failed to snapshot runtime ${ref} - ${reason}`;
+                            return msg;
+                        },
+                    },
+                    pending: { message: `Taking a snapshot of runtime ${ref}…` },
+                    success: {
+                        message: () => `Runtime ${ref} successfully snapshotted as ${snapshotName}.`,
+                    },
+                });
+                await task;
+                if (snapshot) {
+                    addSandboxSnapshot(snapshot);
+                }
+            }
+        }
+        finally {
+            setTakingSandboxSnapshot(false);
+        }
+    }, [connection, podName, multiServiceManager]);
+    return (_jsxs(_Fragment, { children: [_jsxs(ActionMenu, { children: [_jsx(ActionMenu.Button, { leadingVisual: DeviceCameraIcon, variant: "invisible", size: "small", disabled: loadingSandboxSnapshot || takingSandboxSnapshot || disabled, children: children }), _jsx(ActionMenu.Overlay, { children: _jsxs(ActionList, { children: [_jsx(ActionList.Item, { onSelect: onLoadSandboxSnapshot, disabled: loadingSandboxSnapshot || runtimeSnapshots.length === 0, children: "Load a code sandbox snapshot\u2026" }), _jsx(ActionList.Item, { onSelect: onTakeSandboxSnapshot, disabled: takingSandboxSnapshot, children: "Take a code sandbox snapshot" })] }) })] }), openLoadDialog && (_jsx(Dialog, { title: _jsx("span", { style: { color: 'var(--fgColor-default)' }, children: "Choose a code sandbox snapshot to load" }), onClose: () => {
+                    setOpenLoadDialog(false);
+                }, footerButtons: [
+                    {
+                        buttonType: 'default',
+                        content: 'Cancel',
+                        onClick: event => {
+                            if (!event.defaultPrevented) {
+                                event.preventDefault();
+                                setOpenLoadDialog(false);
+                            }
+                        },
+                    },
+                    {
+                        buttonType: 'primary',
+                        content: loadingSandboxSnapshot ? (_jsx(Spinner, { size: "small" })) : ('Load'),
+                        disabled: loadingSandboxSnapshot,
+                        onClick: async (event) => {
+                            if (!event.defaultPrevented) {
+                                event.preventDefault();
+                                setLoadingSandboxSnapshot(true);
+                                try {
+                                    setError(undefined);
+                                    const snapshot = runtimeSnapshots.find(s => s.id === selection);
+                                    if (snapshot && (connection || podName)) {
+                                        await onLoadSandboxSnapshotSubmit({
+                                            connection,
+                                            id: snapshot.id,
+                                            podName,
+                                        });
+                                    }
+                                    else {
+                                        setError('No code sandbox snapshot found.');
+                                    }
+                                }
+                                finally {
+                                    setLoadingSandboxSnapshot(false);
+                                    setOpenLoadDialog(false);
+                                }
+                            }
+                        },
+                        autoFocus: true,
+                    },
+                ], children: _jsxs(Box, { as: "form", children: [_jsxs(FormControl, { children: [_jsx(FormControl.Label, { children: "Snapshot" }), _jsx(Select, { name: "snapshot", value: selection, onChange: onSandboxSnapshotChanged, block: true, children: runtimeSnapshots.map(s => (_jsx(Select.Option, { value: s.id, children: s.name ? `${s.name} (${s.id})` : s.id }, s.id))) })] }), error && _jsx(Flash, { variant: "danger", children: error })] }) }))] }));
+}

package/lib/components/snapshots/index.d.ts

@@ -0,0 +1 @@
+export * from './SandboxSnapshotMenu';

package/lib/components/snapshots/index.js

@@ -0,0 +1,5 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+export * from './SandboxSnapshotMenu';

package/lib/components/snippets/SnippetDialog.d.ts

@@ -0,0 +1,42 @@
+import { CodeCellModel } from '@jupyterlab/cells';
+import type { IMarkdownParser, IRenderMime } from '@jupyterlab/rendermime';
+import { ITranslator } from '@jupyterlab/translation';
+import type { ISnippet } from '../../models';
+/**
+ * {@link SnippetDialog} properties
+ */
+export interface ISnippetDialogProps {
+    /**
+     * Code cell model
+     */
+    model: CodeCellModel;
+    /**
+     * Callback request the dialog closure.
+     */
+    onClose: () => void;
+    /**
+     * Code snippets language
+     */
+    language: string;
+    /**
+     * Code snippets
+     */
+    snippets: ISnippet[];
+    /**
+     * Markdown parser
+     */
+    markdownParser?: IMarkdownParser;
+    /**
+     * HTML sanitizer
+     */
+    sanitizer?: IRenderMime.ISanitizer;
+    /**
+     * Application translator
+     */
+    translator?: ITranslator;
+}
+/**
+ * Dialog to inject snippet in a cell.
+ */
+export declare function SnippetDialog(props: ISnippetDialogProps): JSX.Element;
+export default SnippetDialog;

package/lib/components/snippets/SnippetDialog.js

@@ -0,0 +1,42 @@
+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.
+ */
+import { useCallback, useMemo, useState } from 'react';
+import { nullTranslator } from '@jupyterlab/translation';
+import { FormControl, Select, Text } from '@primer/react';
+import { Box } from '@datalayer/primer-addons';
+import { Dialog } from '@primer/react/experimental';
+import { Markdown } from '@datalayer/core/lib/components/display';
+/**
+ * Dialog to inject snippet in a cell.
+ */
+export function SnippetDialog(props) {
+    const { model, onClose, language, snippets, markdownParser, sanitizer, translator, } = props;
+    const [selection, setSelection] = useState(snippets[0]);
+    const trans = useMemo(() => (translator ?? nullTranslator).load('jupyterlab'), [translator]);
+    const onSelectionChange = useCallback((e) => {
+        const selection = e.target.value;
+        setSelection(snippets[parseInt(selection, 10)]);
+    }, [setSelection, snippets]);
+    const injectSnippet = useCallback(() => {
+        const size = model.sharedModel.getSource().length;
+        model.sharedModel.updateSource(size, size, '\n'.repeat(size ? 2 : 0) + selection.code);
+        onClose();
+    }, [model, selection, onClose]);
+    return (_jsx(Dialog, { title: _jsx("span", { style: { color: 'var(--fgColor-default)' }, children: "Pick a snippet to inject" }), onClose: onClose, footerButtons: [
+            {
+                buttonType: 'default',
+                content: trans.__('Cancel'),
+                onClick: onClose,
+            },
+            {
+                buttonType: 'primary',
+                content: trans.__('Inject snippet'),
+                onClick: injectSnippet,
+                autoFocus: true,
+            },
+        ], children: _jsx(Box, { as: "form", children: _jsxs(FormControl, { children: [_jsx(FormControl.Label, {}), _jsx(Select, { block: true, onChange: onSelectionChange, children: snippets.map((snippet, index) => (_jsx(Select.Option, { value: `${index}`, children: snippet.title }, index))) }), _jsxs(FormControl.Caption, { children: [selection.description && (_jsx(Text, { as: "p", children: selection.description })), markdownParser ? (_jsx(Markdown, { markdownParser: markdownParser, sanitizer: sanitizer, text: `\`\`\`${language}\n${selection.code}\`\`\`` })) : (_jsx("code", { children: selection.code }))] })] }) }) }));
+}
+export default SnippetDialog;

package/lib/components/students/StudentItemStatus.d.ts

@@ -0,0 +1,7 @@
+import { IStudent, IStudentItem } from '../../models';
+type Props = {
+    student?: IStudent;
+    studentItem?: IStudentItem;
+};
+export declare const StudentItemStatus: (props: Props) => import("react/jsx-runtime").JSX.Element;
+export default StudentItemStatus;

package/lib/components/students/StudentItemStatus.js

@@ -0,0 +1,68 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { StudentResultCircle } from '@datalayer/core/lib/components/students/StudentResultCircle';
+const getExerciseScore = (studentItem) => {
+    if (studentItem && studentItem.score) {
+        return studentItem.score;
+    }
+    return 0;
+};
+export const StudentItemStatus = (props) => {
+    const { studentItem } = props;
+    if (!studentItem) {
+        return _jsx(StudentResultCircle, { status: "none", label: "No result yet" });
+    }
+    switch (studentItem.itemType) {
+        case 'dataset': {
+            if (studentItem.completed === undefined) {
+                return (_jsx(StudentResultCircle, { status: "none", label: "Dataset not started" }));
+            }
+            const completed = Boolean(studentItem.completed);
+            return (_jsx(StudentResultCircle, { status: completed ? 'pass' : 'fail', label: completed ? 'Dataset completed' : 'Dataset not completed' }));
+        }
+        case 'lesson': {
+            if (studentItem.completed === undefined) {
+                return _jsx(StudentResultCircle, { status: "none", label: "Lesson not started" });
+            }
+            const completed = Boolean(studentItem.completed);
+            return (_jsx(StudentResultCircle, { status: completed ? 'pass' : 'fail', label: completed ? 'Lesson completed' : 'Lesson not completed' }));
+        }
+        case 'exercise': {
+            const hasResult = Boolean(studentItem.id) ||
+                Boolean(studentItem.codeStudent) ||
+                studentItem.score !== undefined;
+            if (!hasResult) {
+                return (_jsx(StudentResultCircle, { status: "none", label: "Exercise not started" }));
+            }
+            const passed = getExerciseScore(studentItem) > 0;
+            return (_jsx(StudentResultCircle, { status: passed ? 'pass' : 'fail', label: passed ? 'Exercise passed' : 'Exercise failed' }));
+        }
+        case 'assignment': {
+            const hasRecordedAttempt = Boolean(studentItem.id) ||
+                studentItem.nbgradesTotalScore !== undefined ||
+                studentItem.nbgradesTotalPoints !== undefined ||
+                Boolean(studentItem.nbgrades);
+            if (!hasRecordedAttempt) {
+                return (_jsx(StudentResultCircle, { status: "none", label: "Assignment not graded" }));
+            }
+            const totalScore = studentItem.nbgradesTotalScore ?? 0;
+            const totalPoints = studentItem.nbgradesTotalPoints ?? 0;
+            const nbgrades = Array.isArray(studentItem.nbgrades)
+                ? studentItem.nbgrades
+                : [];
+            const status = totalPoints === 0
+                ? 'pass'
+                : totalScore <= 0
+                    ? 'fail'
+                    : totalScore >= totalPoints
+                        ? 'pass'
+                        : 'partial';
+            const tooltip = nbgrades.length > 0
+                ? `Assignment graded: ${totalScore} / ${totalPoints} (${nbgrades.length} checks)`
+                : `Assignment graded: ${totalScore} / ${totalPoints}`;
+            return _jsx(StudentResultCircle, { status: status, label: tooltip });
+        }
+        default:
+            return _jsx(StudentResultCircle, { status: "none", label: "No result yet" });
+    }
+};
+export default StudentItemStatus;

package/lib/components/students/index.d.ts

@@ -0,0 +1 @@
+export * from './StudentItemStatus';

package/lib/components/students/index.js

@@ -0,0 +1,5 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+export * from './StudentItemStatus';

package/lib/components/tokens/SpaceVariantToken.d.ts

@@ -0,0 +1,5 @@
+import { ISpaceVariant } from '../../models';
+export declare const SpaceVariantToken: (props: {
+    variant: ISpaceVariant | string;
+}) => import("react/jsx-runtime").JSX.Element;
+export default SpaceVariantToken;

package/lib/components/tokens/SpaceVariantToken.js

@@ -0,0 +1,23 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { Token } from '@primer/react';
+import { ProjectIcon } from '@primer/octicons-react';
+import { StudentIcon } from '@datalayer/icons-react';
+export const SpaceVariantToken = (props) => {
+    const variant = String(props.variant || 'default').toLowerCase();
+    if (variant.includes('project')) {
+        return _jsx(Token, { text: "project", leadingVisual: ProjectIcon });
+    }
+    switch (variant) {
+        case 'default':
+            return _jsx(Token, { text: "default" });
+        case 'course':
+            return _jsx(Token, { text: "course", leadingVisual: StudentIcon });
+        default:
+            return _jsx(Token, { text: String(variant || 'default') });
+    }
+};
+export default SpaceVariantToken;

package/lib/components/tokens/index.d.ts

@@ -0,0 +1 @@
+export * from './SpaceVariantToken';

package/lib/components/tokens/index.js

@@ -0,0 +1,5 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+export * from './SpaceVariantToken';

package/lib/components/toolbars/AssignmentEditorToolbar.d.ts

@@ -0,0 +1,4 @@
+export declare const AssignmentEditorToolbar: (props: {
+    notebookId: string;
+}) => import("react/jsx-runtime").JSX.Element;
+export default AssignmentEditorToolbar;

package/lib/components/toolbars/AssignmentEditorToolbar.js

@@ -0,0 +1,18 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { Button } from '@primer/react';
+import { Box } from '@datalayer/primer-addons';
+import { RepoPushIcon } from '@primer/octicons-react';
+// import { PlayIcon, StopIcon } from '@primer/octicons-react';
+// import { notebookStore } from '@datalayer/jupyter-react';
+import { useGradeStore } from '../../state/substates';
+export const AssignmentEditorToolbar = (props) => {
+    //  const { notebookId } = props;
+    //   const notebook = notebookStore.getState().selectNotebook(notebookId);
+    const { grade } = useGradeStore();
+    return (_jsx(Box, { display: "flex", children: _jsx(Box, { children: _jsx(Button, { variant: "invisible", size: "small", leadingVisual: RepoPushIcon, onClick: () => grade(new Date()), children: "Grade" }) }) }));
+};
+export default AssignmentEditorToolbar;

package/lib/components/toolbars/DocumentEditorToolbar.d.ts

@@ -0,0 +1,2 @@
+export declare const DocumentEditorToolbar: () => import("react/jsx-runtime").JSX.Element;
+export default DocumentEditorToolbar;

package/lib/components/toolbars/DocumentEditorToolbar.js

@@ -0,0 +1,12 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { Button, Box } from '@primer/react';
+import { RepoPushIcon } from '@primer/octicons-react';
+import { documentStore } from '../../state/substates';
+export const DocumentEditorToolbar = () => {
+    return (_jsx(Box, { display: "flex", children: _jsx(Box, { children: _jsx(Button, { variant: "invisible", size: "small", leadingVisual: RepoPushIcon, onClick: () => documentStore.getState().save(new Date()), children: "Save" }) }) }));
+};
+export default DocumentEditorToolbar;