@datalayer/agent-runtimes 1.0.10 → 1.0.18

package/lib/components/runtimes/RuntimeTransfer.d.ts

@@ -0,0 +1,16 @@
+import { type IRuntimeOptions } from '../../runtimes';
+export interface RuntimeTransfer {
+    /**
+     * Selected Kernel.
+     */
+    runtime: Partial<Omit<IRuntimeOptions, 'kernelType'> & {
+        id: string;
+    }> | null;
+    /**
+     * List of selected variables
+     *
+     * It may differ with the serialized variables if
+     * some serialization failed.
+     */
+    selectedVariables: string[];
+}

package/lib/components/runtimes/RuntimeTransfer.js

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

package/lib/components/runtimes/RuntimeUtils.d.ts

@@ -0,0 +1,17 @@
+import { SessionContext } from '@jupyterlab/apputils';
+import { ITranslator } from '@jupyterlab/translation';
+import { IMultiServiceManager } from '../../runtimes';
+import { IRuntimeDesc } from '../../models';
+export type IDatalayerRuntimeDesc = IRuntimeDesc & {
+    gpu?: string;
+};
+/**
+ * Create the grouped runtime descriptions.
+ */
+export declare function getGroupedRuntimeDescs(multiServiceManager: IMultiServiceManager, kernelId?: string, translator?: ITranslator, filterKernels?: (desc: IDatalayerRuntimeDesc) => boolean, variant?: 'document' | 'cell'): {
+    [g: string]: IDatalayerRuntimeDesc[];
+} | undefined;
+/**
+ * Get the default kernel name given a selector.
+ */
+export declare function getDefaultKernelName(selector: SessionContext.IKernelSearch): string | null;

package/lib/components/runtimes/RuntimeUtils.js

@@ -0,0 +1,178 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { PathExt } from '@jupyterlab/coreutils';
+import { nullTranslator } from '@jupyterlab/translation';
+const ASSIGN_NEW_RUNTIME_LABEL = 'Assign a new Runtime';
+const ASSIGN_EXISTING_REMOTE_RUNTIME_LABEL = 'Assign an existing Remote Runtime';
+const ASSIGN_EXISTING_RUNTIME_LABEL = 'Assign an existing Runtime';
+/**
+ * Create the grouped runtime descriptions.
+ */
+export function getGroupedRuntimeDescs(multiServiceManager, kernelId, translator, filterKernels = () => true, variant) {
+    translator = translator ?? nullTranslator;
+    const trans = translator.load('jupyterlab');
+    const specs = multiServiceManager.local.kernelspecs.specs;
+    const sessions = multiServiceManager.local.sessions.running();
+    const kernels = {};
+    // Add the sessions.
+    const runningSessions = Array.from(sessions)
+        .filter(session => session.kernel &&
+        session.kernel.id !== kernelId &&
+        specs.kernelspecs[session.kernel.name])
+        .map(session => {
+        const spec = specs.kernelspecs[session.kernel.name];
+        return {
+            kernelId: session.kernel.id,
+            name: spec.name,
+            language: spec.language,
+            displayName: session.name || PathExt.basename(session.path),
+            location: 'local',
+        };
+    })
+        .concat(Array.from(multiServiceManager.browser?.sessions.running() ?? [])
+        .filter(session => session.kernel && session.kernel.id !== kernelId)
+        .map(session => {
+        const spec = multiServiceManager.browser.kernelspecs.specs.kernelspecs[session.kernel.name];
+        return {
+            id: '', // TODO Assign a proper ID.
+            kernelId: session.kernel.id,
+            name: spec.name,
+            language: spec.language,
+            displayName: session.name || PathExt.basename(session.path),
+            location: 'browser',
+        };
+    }))
+        .filter(filterKernels);
+    // Add the running runtimes.
+    const listedAsSession = runningSessions.map(s => s.kernelId);
+    const runningKernels = Array.from(multiServiceManager.local.kernels.running())
+        .filter(k => !listedAsSession.includes(k.id))
+        .map(k => {
+        const spec = specs.kernelspecs[k.name];
+        return {
+            kernelId: k.id,
+            name: spec.name,
+            language: spec.language,
+            displayName: spec.display_name,
+            location: 'local',
+        };
+    })
+        .concat((multiServiceManager.remote?.runtimesManager.get() ?? [])
+        .filter(k => k.id && !listedAsSession.includes(k.id))
+        .map(runtime => {
+        const environment = multiServiceManager
+            .remote.environments.get()
+            .find(env => env.name === runtime.environment_name);
+        return {
+            kernelId: runtime.id,
+            name: environment.name,
+            language: environment.language,
+            displayName: runtime.given_name ?? environment.title,
+            location: 'remote',
+            podName: runtime.pod_name,
+            gpu: environment.resources?.['nvidia.com/gpu'],
+        };
+    }))
+        .concat(Array.from(multiServiceManager.browser?.kernels.running() ?? [])
+        .filter(k => !listedAsSession.includes(k.id))
+        .map(k => {
+        const spec = multiServiceManager.browser.kernelspecs.specs.kernelspecs[k.name];
+        return {
+            kernelId: k.id,
+            name: spec.name,
+            language: spec.language,
+            displayName: spec.display_name,
+            location: 'browser',
+        };
+    }))
+        .filter(filterKernels);
+    runningSessions.push(...runningKernels);
+    if (runningSessions.length) {
+        const key = variant === 'cell'
+            ? ASSIGN_EXISTING_REMOTE_RUNTIME_LABEL
+            : ASSIGN_EXISTING_RUNTIME_LABEL;
+        kernels[key] = runningSessions;
+    }
+    // Environments.
+    const environments = Object.values(specs.kernelspecs)
+        .filter(spec => !!spec)
+        .map(spec => ({
+        name: spec.name,
+        language: spec.language,
+        displayName: spec.display_name,
+        gpu: spec.resources?.['nvidia.com/gpu'],
+        location: 'local',
+    }))
+        .filter(filterKernels);
+    environments.push(...(multiServiceManager.remote?.environments
+        .get()
+        .map(spec => ({
+        name: spec.name,
+        language: spec.language,
+        displayName: spec.title,
+        location: 'remote',
+        gpu: spec.resources?.['nvidia.com/gpu'],
+        burningRate: spec.burning_rate,
+    }))
+        .filter(filterKernels) ?? []));
+    environments.push(...Object.values(multiServiceManager.browser?.kernelspecs.specs?.kernelspecs ?? {})
+        .filter(spec => !!spec)
+        .map(spec => ({
+        name: spec.name,
+        language: spec.language,
+        displayName: spec.display_name,
+        location: 'browser',
+    }))
+        .filter(filterKernels));
+    if (environments.length) {
+        kernels[trans.__(ASSIGN_NEW_RUNTIME_LABEL)] = environments;
+    }
+    return kernels;
+}
+/**
+ * Get the default kernel name given a selector.
+ */
+export function getDefaultKernelName(selector) {
+    const { specs, preference } = selector;
+    const { name, language, canStart, autoStartDefault } = preference;
+    if (!specs || canStart === false) {
+        return null;
+    }
+    const defaultName = autoStartDefault ? specs.default : null;
+    if (!name && !language) {
+        return defaultName;
+    }
+    // Look for an exact match of a spec name.
+    for (const specName in specs.kernelspecs) {
+        if (specName === name) {
+            return name;
+        }
+    }
+    // Bail if there is no language.
+    if (!language) {
+        return defaultName;
+    }
+    // Check for a single kernel matching the language.
+    const matches = [];
+    for (const specName in specs.kernelspecs) {
+        const kernelLanguage = specs.kernelspecs[specName]?.language;
+        if (language === kernelLanguage) {
+            matches.push(specName);
+        }
+    }
+    if (matches.length === 1) {
+        const specName = matches[0];
+        console.warn('No exact match found for ' +
+            specName +
+            ', using runtime ' +
+            specName +
+            ' that matches ' +
+            'language=' +
+            language);
+        return specName;
+    }
+    // No matches found.
+    return defaultName;
+}

package/lib/components/runtimes/RuntimeVariables.d.ts

@@ -0,0 +1,38 @@
+import { ReactElement } from 'react';
+import { ITranslator } from '@jupyterlab/translation';
+/**
+ * {@link RuntimeVariables} properties
+ */
+export interface IRuntimeVariablesProps {
+    /**
+     * Component class name
+     */
+    className?: string;
+    /**
+     * Available kernel variables
+     *
+     * Mapping (variable name, variable type)
+     */
+    kernelVariables?: {
+        [name: string]: string;
+    };
+    /**
+     * Kernel variables to be transferred.
+     */
+    selectedVariables: string[];
+    setSelectVariable: (l: string[]) => void;
+    /**
+     * Whether to transfer the variable from the current
+     * to the selected kernel or not.
+     */
+    transferVariables: boolean;
+    setTransferVariable: (v: boolean) => void;
+    /**
+     * Application translator
+     */
+    translator?: ITranslator;
+}
+/**
+ * Runtime variables selector component.
+ */
+export declare function RuntimeVariables(props: IRuntimeVariablesProps): ReactElement;

package/lib/components/runtimes/RuntimeVariables.js

@@ -0,0 +1,75 @@
+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 { useMemo } from 'react';
+import { IconButton, ToggleSwitch, FormControl } from '@primer/react';
+import { Box } from '@datalayer/primer-addons';
+import { Blankslate, DataTable, Table } from '@primer/react/experimental';
+import { nullTranslator } from '@jupyterlab/translation';
+import { checkIcon } from '@jupyterlab/ui-components';
+/**
+ * Runtime variables selector component.
+ */
+export function RuntimeVariables(props) {
+    const { className, translator, selectedVariables, setSelectVariable, transferVariables, setTransferVariable, kernelVariables, } = props;
+    const trans = useMemo(() => (translator ?? nullTranslator).load('jupyterlab'), [translator]);
+    const nRows = Object.keys(kernelVariables ?? {}).length;
+    // Sorting and actions does not play nice together :'(
+    const columns = [
+        {
+            header: trans.__('Name'),
+            field: 'name',
+            rowHeader: true,
+        },
+        {
+            header: trans.__('Type'),
+            field: 'type',
+        },
+        {
+            id: 'select',
+            maxWidth: '70px',
+            header: () => (_jsx(IconButton, { "aria-label": selectedVariables.length === nRows
+                    ? trans.__('Deselect all')
+                    : trans.__('Select all'), title: selectedVariables.length === nRows
+                    ? trans.__('Deselect all')
+                    : trans.__('Select all'), icon: selectedVariables.length === nRows
+                    ? checkIcon.react
+                    : () => _jsx("span", {}), variant: "default", size: "small", onClick: e => {
+                    e.preventDefault();
+                    if (selectedVariables.length === nRows) {
+                        setSelectVariable([]);
+                    }
+                    else {
+                        setSelectVariable(Object.keys(kernelVariables ?? {}));
+                    }
+                } })),
+            renderCell: (row) => {
+                const isSelected = selectedVariables.includes(row.name);
+                return (_jsx(IconButton, { "aria-label": isSelected
+                        ? trans.__('Deselect: %1', row.name)
+                        : trans.__('Select: %1', row.name), title: isSelected
+                        ? trans.__('Deselect: %1', row.name)
+                        : trans.__('Select: %1', row.name), icon: isSelected ? checkIcon.react : () => _jsx("span", {}), variant: "default", size: "small", onClick: e => {
+                        e.preventDefault();
+                        const index = selectedVariables.findIndex(v => v === row.name);
+                        if (index >= 0) {
+                            const copy = [...selectedVariables];
+                            copy.splice(index, 1);
+                            setSelectVariable(copy);
+                        }
+                        else {
+                            setSelectVariable([...selectedVariables, row.name]);
+                        }
+                    } }));
+            },
+        },
+    ];
+    return (_jsxs(Box, { className: className, sx: { paddingTop: '10px' }, children: [_jsxs(FormControl, { layout: "horizontal", children: [_jsx(FormControl.Label, { children: trans.__('Transfer variables') }), _jsx(ToggleSwitch, { checked: transferVariables, size: "small", onClick: e => {
+                            e.preventDefault();
+                            setTransferVariable(!transferVariables);
+                        }, "aria-labelledby": "kernel-toggle-variables" })] }), transferVariables && (_jsxs(Table.Container, { sx: { flex: '1 1 auto', marginTop: 3 }, children: [_jsx(Table.Subtitle, { as: "p", id: "dla-kernel-variables-subtitle", children: trans.__('The list of transferable runtime variables.') }), kernelVariables ? (Object.keys(kernelVariables ?? {}).length ? (_jsx(DataTable, { "aria-labelledby": "dla-kernel-variables", "aria-describedby": "dla-kernel-variables-subtitle", data: Object.entries(kernelVariables ?? {})
+                            .map(([name, type], id) => ({ id, name, type }))
+                            .sort((a, b) => (a.name > b.name ? 1 : -1)), columns: columns, cellPadding: "condensed" })) : (_jsx(Box, { sx: { gridArea: 'table' }, children: _jsx(Blankslate, { border: true, children: _jsx(Blankslate.Heading, { children: trans.__('No eligible variables.') }) }) }))) : (_jsx(Table.Skeleton, { "aria-labelledby": "dla-kernel-variables", "aria-describedby": "dla-kernel-variables-subtitle", columns: columns, rows: 5 }))] }))] }));
+}

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

@@ -0,0 +1,11 @@
+export * from './RuntimeCellVariables';
+export * from './RuntimeCellVariablesDialog';
+export * from './RuntimeLauncherDialog';
+export * from './RuntimePickerBase';
+export * from './RuntimePickerCell';
+export * from './RuntimePickerNotebook';
+export * from './RuntimeReservationControl';
+export * from './RuntimeSimplePicker';
+export * from './RuntimeTransfer';
+export * from './RuntimeUtils';
+export * from './RuntimeVariables';

package/lib/components/runtimes/index.js

@@ -0,0 +1,15 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+export * from './RuntimeCellVariables';
+export * from './RuntimeCellVariablesDialog';
+export * from './RuntimeLauncherDialog';
+export * from './RuntimePickerBase';
+export * from './RuntimePickerCell';
+export * from './RuntimePickerNotebook';
+export * from './RuntimeReservationControl';
+export * from './RuntimeSimplePicker';
+export * from './RuntimeTransfer';
+export * from './RuntimeUtils';
+export * from './RuntimeVariables';

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

@@ -0,0 +1,54 @@
+import { type Icon } from '@primer/octicons-react';
+import { type ScheduleDoc } from '../../api/scheduler/schedules';
+/**
+ * Supported schedule presets.
+ */
+export type SchedulePreset = 'every-minute' | 'hourly' | 'daily' | 'custom';
+/**
+ * Props for the self-contained {@link ScheduleMenu} component.
+ *
+ * The component performs the scheduler service calls internally. Provide the
+ * `notebookUid`, an authentication `token`, and the scheduler service
+ * `baseUrl` (configurable via props) to enable scheduling.
+ */
+export type ScheduleMenuProps = {
+    /** Target notebook uid to schedule (used to create/update a schedule). */
+    notebookUid?: string;
+    /**
+     * Existing schedule uid to update in place. When provided, changes are
+     * persisted with a PUT update instead of a notebook upsert.
+     */
+    scheduleUid?: string;
+    /** Authentication token used for scheduler API calls. */
+    token?: string;
+    /** Base URL of the scheduler service. Defaults to the production service. */
+    baseUrl?: string;
+    /** Force-disable the menu. When omitted, the menu is enabled if a token and notebook uid are present. */
+    enabled?: boolean;
+    /** Icon shown on the anchor button (replaced by a spinner while saving). */
+    icon?: Icon;
+    /** Optional color for the anchor icon. */
+    iconColor?: string;
+    /** Accessible label for the anchor button. */
+    ariaLabel?: string;
+    /** Initial preset selection. */
+    initialPreset?: SchedulePreset;
+    /** Initial cron expression. */
+    initialCronExpression?: string;
+    /** Called after a schedule is successfully saved. */
+    onSaved?: (schedule: ScheduleDoc) => void;
+    /** Called after a schedule is successfully deleted/disabled. */
+    onDeleted?: (schedule: ScheduleDoc) => void;
+    /** Called when saving a schedule fails. */
+    onError?: (error: unknown) => void;
+};
+/**
+ * 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 declare const ScheduleMenu: ({ notebookUid, scheduleUid, token, baseUrl, enabled, icon, iconColor, ariaLabel, initialPreset, initialCronExpression, onSaved, onDeleted, onError, }: ScheduleMenuProps) => import("react/jsx-runtime").JSX.Element;
+export default ScheduleMenu;

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 {};