@datalayer/core 0.0.1 → 0.0.2

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

@@ -0,0 +1,43 @@
+import { ITranslator } from '@jupyterlab/translation';
+import { CommandRegistry } from '@lumino/commands';
+import type { IMultiServiceManager } from '../../api';
+import { IDatalayerSessionContext } from '../../api';
+import { RuntimeTransfer } from './RuntimeTransfer';
+/**
+ * {@link RuntimePickerNotebook} properties
+ */
+export interface IRuntimePickerNotebookProps {
+    /**
+     * Callback to allow the user to login
+     */
+    logIn?: () => void;
+    /**
+     * Document session context
+     */
+    sessionContext: IDatalayerSessionContext;
+    /**
+     * Multi service manager
+     */
+    multiServiceManager: IMultiServiceManager;
+    /**
+     * Set the selected kernel
+     */
+    setValue: (v: RuntimeTransfer | Error) => void;
+    /**
+     * Close the dialog
+     */
+    close: () => void;
+    /**
+     * Command registry
+     */
+    commands: CommandRegistry;
+    /**
+     * Application translator
+     */
+    translator?: ITranslator;
+}
+/**
+ * Runtime Picker components for a Notebook.
+ */
+export declare function RuntimePickerNotebook(props: IRuntimePickerNotebookProps): JSX.Element;
+export default RuntimePickerNotebook;

package/lib/components/runtimes/RuntimePickerNotebook.js

@@ -0,0 +1,173 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/*
+ * Copyright (c) 2021-2024 Datalayer, Inc.
+ *
+ * Datalayer License
+ */
+import { useCallback, useEffect, useState } from 'react';
+import { ActionList, FormControl, ToggleSwitch, Tooltip, IconButton } from '@primer/react';
+import { Box } from "@datalayer/primer-addons";
+import { AlertIcon } from '@primer/octicons-react';
+import { JSONExt } from '@lumino/coreutils';
+import { KernelExecutor } from '@datalayer/jupyter-react';
+import { RuntimeSnippetsFacade } from '../../api';
+import { ExternalTokenSilentLogin } from '../../components/iam';
+import { useCoreStore, useIAMStore } from '../../state';
+import { RuntimeReservationControl, MAXIMAL_RUNTIME_TIME_RESERVATION_MINUTES } from './RuntimeReservationControl';
+import { RuntimeVariables } from './RuntimeVariables';
+import { RuntimePickerBase } from './RuntimePickerBase';
+import { DatalayerThemeProvider } from '../../theme';
+/**
+ * Runtime Picker components for a Notebook.
+ */
+export function RuntimePickerNotebook(props) {
+    const { multiServiceManager, sessionContext, setValue, translator } = props;
+    const { configuration } = useCoreStore();
+    const { credits, refreshCredits, token } = useIAMStore();
+    const [selectedRuntimeDesc, setSelectedRuntimeDesc] = useState();
+    const [timeLimit, setTimeLimit] = useState(Math.min(credits?.available ?? 0, 10));
+    const [userStorage, setUserStorage] = useState(false);
+    const [canTransferFrom, setTransferFrom] = useState(false);
+    const [canTransferTo, setTransferTo] = useState(false);
+    const [transferVariables, setTransferVariables] = useState(false);
+    const [hasLoadedVariables, setHasLoadedVariables] = useState(false);
+    const [kernelVariables, setRuntimeVariables] = useState();
+    const [toTransfer, setToTransfer] = useState([]);
+    useEffect(() => {
+        refreshCredits();
+    }, []);
+    useEffect(() => {
+        const specs = sessionContext.specsManager.specs?.kernelspecs;
+        if (sessionContext.session?.kernel?.name && specs) {
+            const spec = Object.values(specs).find(spec => spec?.name === sessionContext.session.kernel.name);
+            if (spec) {
+                setSelectedRuntimeDesc({
+                    name: spec.name,
+                    kernelId: sessionContext.session.kernel.id,
+                    location: sessionContext.location,
+                    language: spec.language,
+                    displayName: sessionContext.kernelDisplayName
+                });
+                setTransferFrom(RuntimeSnippetsFacade.supports(spec.language));
+            }
+        }
+    }, [sessionContext]);
+    const listRuntimeVariables = useCallback(async () => {
+        if (hasLoadedVariables) {
+            return Promise.resolve();
+        }
+        setHasLoadedVariables(true);
+        const connection = sessionContext.session.kernel;
+        const spec = sessionContext.specsManager.specs.kernelspecs[connection.model.name];
+        const snippets = new RuntimeSnippetsFacade(spec.language);
+        const outputs = await new KernelExecutor({ connection }).execute(snippets.listVariables());
+        const content = outputs.get(0).data['text/plain'];
+        if (content) {
+            setRuntimeVariables(JSON.parse(
+            // We need to remove the quotes prior to parsing.
+            content.slice(1, content.length - 1)));
+            if (toTransfer.length) {
+                const candidates = Object.keys(kernelVariables ?? {});
+                setToTransfer(toTransfer.filter(n => candidates.includes(n)));
+            }
+            else {
+                // By default select all variables.
+                setToTransfer(Object.keys(kernelVariables ?? {}));
+            }
+        }
+        else {
+            setRuntimeVariables({});
+        }
+    }, [hasLoadedVariables, kernelVariables, toTransfer]);
+    const setSelectedVariables = useCallback((l) => {
+        if (!JSONExt.deepEqual(toTransfer, l)) {
+            setToTransfer(l);
+        }
+    }, [toTransfer]);
+    const setTransferVariable = useCallback((value) => {
+        if (transferVariables !== value) {
+            if (value) {
+                listRuntimeVariables().catch(error => {
+                    console.error('Failed to list the runtime variable', error);
+                    setHasLoadedVariables(false);
+                });
+            }
+            setTransferVariables(value);
+        }
+    }, [transferVariables]);
+    const setRuntimeDesc = useCallback((runtimeDesc) => {
+        if (!runtimeDesc) {
+            if (selectedRuntimeDesc) {
+                setSelectedRuntimeDesc(undefined);
+                setTransferTo(false);
+            }
+            return;
+        }
+        if (selectedRuntimeDesc?.displayName !== runtimeDesc.displayName || selectedRuntimeDesc?.kernelId !== runtimeDesc.kernelId) {
+            setSelectedRuntimeDesc({ ...runtimeDesc });
+            setTransferTo(RuntimeSnippetsFacade.supports(runtimeDesc.language));
+        }
+    }, [selectedRuntimeDesc]);
+    const handleUserStorageChange = useCallback((e) => {
+        e.preventDefault();
+        setUserStorage(!userStorage);
+    }, [userStorage]);
+    useEffect(() => {
+        const creditsLimit = selectedRuntimeDesc?.location === 'remote' && selectedRuntimeDesc.burningRate
+            ? Math.min(timeLimit, MAXIMAL_RUNTIME_TIME_RESERVATION_MINUTES) *
+                selectedRuntimeDesc.burningRate *
+                60
+            : undefined;
+        setValue(creditsLimit !== 0 ?
+            {
+                kernel: selectedRuntimeDesc
+                    ?
+                        {
+                            environmentName: ['browser', 'remote'].includes(selectedRuntimeDesc.location)
+                                ? `${selectedRuntimeDesc.location}-${selectedRuntimeDesc.name}`
+                                : selectedRuntimeDesc.name,
+                            id: selectedRuntimeDesc.kernelId,
+                            creditsLimit,
+                            capabilities: userStorage ? ['user_storage'] : undefined
+                        }
+                    :
+                        null,
+                selectedVariables: toTransfer,
+            }
+            : new Error('Credits limit must be strictly positive.'));
+    }, [selectedRuntimeDesc, userStorage, toTransfer, timeLimit]);
+    const { kernelPreference: { canStart } } = sessionContext;
+    const max = Math.floor((credits?.available ?? 0) / (selectedRuntimeDesc?.burningRate ?? -1) / 60.0);
+    const outOfCredits = !credits?.available || max < Number.EPSILON;
+    return (_jsx(DatalayerThemeProvider, { children: _jsxs(Box, { as: "form", className: "dla-Runtimes-picker", children: [_jsx(Box, { sx: { padding: 'var(--stack-padding-condensed) 0' }, children: _jsx(RuntimePickerBase, { display: "radio", disabled: canStart === false, preference: {
+                            id: sessionContext.session?.id,
+                            kernelDisplayName: sessionContext.kernelPreference.shouldStart ? sessionContext.kernelDisplayName : undefined,
+                        }, sessionContext: sessionContext, multiServiceManager: multiServiceManager, translator: translator, runtimeDesc: selectedRuntimeDesc, setRuntimeDesc: setRuntimeDesc, postActions: token || !props.logIn ?
+                            /*
+                            <Button
+                              variant="default"
+                              onClick={e => {
+                                e.preventDefault();
+                                commands.execute(CommandIDs.launchRemoteRuntime);
+                                close();
+                              }}
+                            >
+                              Launch a New Runtime
+                            </Button>
+                            */
+                            _jsx(_Fragment, {})
+                            :
+                                _jsx(ActionList.Item, { onSelect: props.logIn, title: 'Connect to Runtime provider.', children: _jsx(ExternalTokenSilentLogin, { message: "Connect to the Runtime provider" }) }) }) }), !selectedRuntimeDesc?.kernelId && selectedRuntimeDesc?.location === 'remote' &&
+                    _jsxs(_Fragment, { children: [_jsx(RuntimeReservationControl, { disabled: outOfCredits || selectedRuntimeDesc?.location !== 'remote', label: 'Time reservation', max: max < 0 ? 1 : max, time: timeLimit, onTimeChange: setTimeLimit, error: outOfCredits && max >= 0 ?
+                                    'You must add credits to your account.'
+                                    : timeLimit === 0
+                                        ? 'You must set a time limit.'
+                                        : undefined, burningRate: selectedRuntimeDesc.burningRate }), !configuration.whiteLabel &&
+                                _jsxs(FormControl, { disabled: !!selectedRuntimeDesc?.kernelId || selectedRuntimeDesc?.location !== 'remote', layout: "horizontal", children: [_jsxs(FormControl.Label, { children: ["User storage", _jsx(Tooltip, { text: 'The runtime will be slower to start.', direction: "e", style: { marginLeft: 3 }, children: _jsx(IconButton, { icon: AlertIcon, "aria-label": "", variant: "invisible" }) })] }), _jsx(ToggleSwitch, { disabled: !!selectedRuntimeDesc?.kernelId || selectedRuntimeDesc?.location !== 'remote', checked: userStorage, size: "small", onClick: handleUserStorageChange })] })] }), canTransferFrom && canTransferTo &&
+                    _jsx(RuntimeVariables, { selectedVariables: toTransfer, setSelectVariable: setSelectedVariables, transferVariables: transferVariables, setTransferVariable: setTransferVariable, kernelVariables: kernelVariables, translator: translator })] }) }));
+}
+export default RuntimePickerNotebook;

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

@@ -0,0 +1,47 @@
+/**
+ * Maximal time reservable for a runtime in minutes.
+ *
+ * TODO this should be configurable
+ */
+export declare const MAXIMAL_RUNTIME_TIME_RESERVATION_MINUTES: number;
+/**
+ * Time control properties
+ */
+export interface IKernelReservationControlProps {
+    /**
+     * Callback on add credits button
+     */
+    addCredits?: () => void;
+    /**
+     * Disabled state
+     */
+    disabled?: boolean;
+    /**
+     * Control error message
+     */
+    error?: string;
+    /**
+     * Control label
+     */
+    label: string;
+    /**
+     * Maximal time
+     */
+    max: number;
+    /**
+     * Callback when time value changes
+     */
+    onTimeChange: (value: number) => void;
+    /**
+     * Time control value
+     */
+    time: number;
+    /**
+     * Burning rate
+     */
+    burningRate?: number;
+}
+/**
+ * Runtime reservation control
+ */
+export declare function RuntimeReservationControl(props: IKernelReservationControlProps): JSX.Element;

package/lib/components/runtimes/RuntimeReservationControl.js

@@ -0,0 +1,43 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/*
+ * Copyright (c) 2021-2024 Datalayer, Inc.
+ *
+ * Datalayer License
+ */
+import { FormControl, IconButton, Text, TextInput } from '@primer/react';
+import { Box } from "@datalayer/primer-addons";
+import { PlusIcon } from '@primer/octicons-react';
+import { Slider } from '@datalayer/primer-addons';
+/**
+ * Maximal time reservable for a runtime in minutes.
+ *
+ * TODO this should be configurable
+ */
+export const MAXIMAL_RUNTIME_TIME_RESERVATION_MINUTES = 24 * 60;
+/**
+ * Runtime reservation control
+ */
+export function RuntimeReservationControl(props) {
+    const { addCredits, burningRate, disabled, error, label, max: maxProps, onTimeChange, time, } = props;
+    const max = Math.min(maxProps, MAXIMAL_RUNTIME_TIME_RESERVATION_MINUTES);
+    // Temporary workaround to not show disabled components.
+    const hidden = disabled;
+    return (!hidden ?
+        _jsxs(FormControl, { disabled: disabled, sx: { paddingBottom: 'var(--stack-padding-condensed)' }, children: [_jsx(FormControl.Label, { children: label }), _jsxs(Box, { style: {
+                        alignItems: 'center',
+                        display: 'grid',
+                        gridTemplateColumns: 'max-content 1fr max-content max-content',
+                        gridGap: 'var(--stack-gap-condensed)',
+                        width: '100%'
+                    }, children: [_jsx(Slider, { step: 1, min: 1, max: max, value: time, onChange: onTimeChange, disabled: disabled, label: "", displayValue: false }), _jsx(TextInput, { type: "number", step: "1", min: "1", max: max, disabled: disabled, value: Math.min(max, time).toFixed(2), onChange: event => {
+                                onTimeChange(parseFloat(event.target.value));
+                            } }), (max === 0 || max > Number.EPSILON) && (_jsxs(_Fragment, { children: [_jsxs(Text, { children: ["out of ", maxProps, " available minutes"] }), addCredits &&
+                                    _jsx(IconButton, { icon: PlusIcon, "aria-label": "Add credits", onClick: () => addCredits() })] }))] }), _jsxs(FormControl.Caption, { children: ["Maximum execution time that can be consumed by the runtime. It must be less than ", (MAXIMAL_RUNTIME_TIME_RESERVATION_MINUTES / 60).toFixed(0), ' ', " hours.", burningRate &&
+                            _jsxs(_Fragment, { children: [_jsx("br", {}), `With the current value, the runtime execution will consume at most ${(time * burningRate * 60).toFixed(2)} credits.`] })] }), error && _jsx(FormControl.Validation, { variant: "error", children: error })] })
+        :
+            _jsx(_Fragment, {}));
+}

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

@@ -0,0 +1,34 @@
+import { Session } from '@jupyterlab/services';
+import { IRuntimeModel, type IRuntimeDesc } from '../../api';
+export interface IRuntimeAssignOptions {
+    /**
+     * Kernel description.
+     */
+    runtimeDesc?: IRuntimeDesc;
+    /**
+     * Kernel model to connect to.
+     */
+    runtimeModel?: IRuntimeModel;
+    /**
+     * Whether to transfer the state to the new Kernel model.
+     */
+    transferState?: boolean;
+}
+/**
+ * Runtime picker component properties.
+ */
+interface IRuntimeSimplePickerProps {
+    /**
+     * Kernel assignment callback.
+     */
+    assignRuntime: (options: IRuntimeAssignOptions) => Promise<void>;
+    /**
+     * Connection to the active Kernel.
+     */
+    sessionConnection?: Session.ISessionConnection;
+}
+/**
+ * Runtime simple picker component.
+ */
+export declare function RuntimeSimplePicker(props: IRuntimeSimplePickerProps): JSX.Element;
+export {};

package/lib/components/runtimes/RuntimeSimplePicker.js

@@ -0,0 +1,161 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/*
+ * Copyright (c) 2021-2024 Datalayer, Inc.
+ *
+ * Datalayer License
+ */
+import { useCallback, useEffect, useState } from 'react';
+import { KernelIndicator } from '@datalayer/jupyter-react';
+import { ISanitizer } from '@jupyterlab/apputils';
+import { IMarkdownParser } from '@jupyterlab/rendermime';
+import { ActionList, ActionMenu, Box, Button, Tooltip } from '@primer/react';
+import { CloudIcon, EyeIcon, UnfoldIcon } from '@primer/octicons-react';
+import { BrowserIcon, PlusIcon } from '@datalayer/icons-react';
+import { ArtifactIcon } from '../../components/icons';
+import { KernelLauncherDialog } from '../../components/runtimes';
+import { useRuntimesStore } from '../../state';
+/**
+ * Cause to open the new Kernel dialog.
+ */
+var KernelDialogCause;
+(function (KernelDialogCause) {
+    /**
+     * Don't open.
+     */
+    KernelDialogCause[KernelDialogCause["None"] = 0] = "None";
+    /**
+     * Launch a new Remote Kernel.
+     */
+    KernelDialogCause[KernelDialogCause["New"] = 1] = "New";
+    /**
+     * Transfer the state from the current Kernel to a new Remote Kernel.
+     */
+    KernelDialogCause[KernelDialogCause["Transfer"] = 2] = "Transfer";
+})(KernelDialogCause || (KernelDialogCause = {}));
+/**
+ * Runtime simple picker component.
+ */
+export function RuntimeSimplePicker(props) {
+    const { assignRuntime: assignKernel, sessionConnection } = props;
+    const { runtimeModels: remoteKernels, multiServiceManager, jupyterLabAdapter } = useRuntimesStore();
+    const [kernelLocation, setKernelLocation] = useState();
+    const [luminoServices, setLuminoServices] = useState({});
+    const [dialogCause, setDialogCause] = useState(KernelDialogCause.None);
+    const [status, setStatus] = useState('');
+    useEffect(() => {
+        if (sessionConnection) {
+            function onStatusChanged(connection) {
+                setStatus(`Runtime ${connection.kernel?.connectionStatus} - Status: ${connection.kernel?.status}`);
+            }
+            onStatusChanged(sessionConnection);
+            sessionConnection?.statusChanged.connect(onStatusChanged);
+            sessionConnection?.connectionStatusChanged.connect(onStatusChanged);
+            return () => {
+                sessionConnection?.statusChanged.disconnect(onStatusChanged);
+                sessionConnection?.connectionStatusChanged.disconnect(onStatusChanged);
+            };
+        }
+        else {
+            setStatus('No kernel');
+        }
+    }, [sessionConnection]);
+    const refreshRemoteKernels = useCallback(async () => {
+        if (multiServiceManager?.remote?.runtimesManager) {
+            await multiServiceManager.remote.runtimesManager.refresh();
+        }
+    }, [multiServiceManager?.remote?.runtimesManager]);
+    const handleLaunchRemoteKernel = useCallback(() => {
+        setDialogCause(KernelDialogCause.New);
+    }, []);
+    const handleCloseDialog = useCallback((runtimeDesc) => {
+        if (runtimeDesc) {
+            switch (dialogCause) {
+                case KernelDialogCause.New:
+                    refreshRemoteKernels().then(() => {
+                        setKernelLocation('remote');
+                        assignKernel({
+                            runtimeDesc,
+                            runtimeModel: multiServiceManager?.remote?.runtimesManager
+                                .get()
+                                .find(model => model.id === runtimeDesc.kernelId)
+                        });
+                    });
+                    break;
+                case KernelDialogCause.Transfer:
+                    setKernelLocation('remote');
+                    assignKernel({ runtimeDesc, transferState: true });
+                    break;
+            }
+        }
+        setDialogCause(KernelDialogCause.None);
+    }, [refreshRemoteKernels, multiServiceManager?.remote, dialogCause]);
+    useEffect(() => {
+        if (jupyterLabAdapter) {
+            Promise.all([
+                jupyterLabAdapter.jupyterLab.resolveOptionalService(IMarkdownParser),
+                jupyterLabAdapter.jupyterLab.resolveOptionalService(ISanitizer)
+            ]).then(services => {
+                setLuminoServices({
+                    [IMarkdownParser.name]: services[0],
+                    [ISanitizer.name]: services[1]
+                });
+            });
+        }
+        else {
+            setLuminoServices({});
+        }
+    }, [jupyterLabAdapter]);
+    return (_jsxs(_Fragment, { children: [_jsxs(ActionMenu, { children: [_jsx(ActionMenu.Button, { leadingVisual: () => {
+                            switch (kernelLocation) {
+                                case 'browser':
+                                    return _jsx(BrowserIcon, {});
+                                case 'remote':
+                                    return _jsx(CloudIcon, {});
+                                case undefined:
+                                    return _jsx(EyeIcon, {});
+                            }
+                            return _jsx(ArtifactIcon, { type: "runtime" });
+                        }, trailingVisual: () => sessionConnection
+                            ?
+                                _jsx(Box, { sx: { paddingTop: '5px' }, children: _jsx(KernelIndicator, { kernel: sessionConnection.kernel }) })
+                            :
+                                _jsx(_Fragment, {}), size: "small", variant: "invisible", children: _jsx(Tooltip, { text: status, direction: "s", children: _jsx(Button, { variant: "invisible", size: "small", children: sessionConnection?.kernel?.name ?? 'Runtimes' }) }) }), _jsx(ActionMenu.Overlay, { width: "medium", children: _jsxs(ActionList, { selectionVariant: "single", showDividers: true, children: [_jsxs(ActionList.Group, { children: [_jsxs(ActionList.Item, { selected: kernelLocation === undefined && sessionConnection === undefined, onSelect: () => {
+                                                setKernelLocation(undefined);
+                                                assignKernel({ runtimeDesc: undefined });
+                                            }, children: [_jsx(ActionList.LeadingVisual, { children: _jsx(EyeIcon, {}) }), "Viewer", _jsx(ActionList.Description, { variant: "block", children: "A simple Notebook Viewer without Runtime." })] }), _jsxs(ActionList.Item, { selected: kernelLocation === 'browser', onSelect: () => {
+                                                setKernelLocation('browser');
+                                                assignKernel({
+                                                    runtimeDesc: {
+                                                        name: 'pyodide',
+                                                        location: 'browser',
+                                                        language: 'python'
+                                                    }
+                                                });
+                                            }, children: [_jsx(ActionList.LeadingVisual, { children: _jsx(BrowserIcon, {}) }), "Browser Runtime", _jsx(ActionList.Description, { variant: "block", children: "A Browser Runtime based on Pyodide." })] })] }), remoteKernels.length > 0 && (_jsxs(ActionList.Group, { children: [_jsx(ActionList.GroupHeading, { children: "Cloud Runtimes" }), remoteKernels.map(kernelModel => {
+                                            return (_jsxs(ActionList.Item, { selected: sessionConnection?.kernel?.id === kernelModel.id, onSelect: () => {
+                                                    setKernelLocation('remote');
+                                                    assignKernel({
+                                                        runtimeDesc: {
+                                                            name: kernelModel.environment_name,
+                                                            language: '',
+                                                            location: 'remote',
+                                                            displayName: kernelModel.given_name,
+                                                            kernelId: kernelModel.id,
+                                                            burningRate: kernelModel.burning_rate,
+                                                            podName: kernelModel.pod_name
+                                                        },
+                                                        runtimeModel: kernelModel
+                                                    });
+                                                }, children: [_jsx(ActionList.LeadingVisual, { children: _jsx(ArtifactIcon, { type: "runtime" }) }), kernelModel.given_name, _jsx(ActionList.Description, { variant: "block", children: kernelModel.environment_name })] }, kernelModel.id));
+                                        })] })), _jsx(ActionList.Divider, {}), _jsxs(ActionList.Group, { children: [_jsxs(ActionList.Item, { selected: false, onSelect: handleLaunchRemoteKernel, children: [_jsx(ActionList.LeadingVisual, { children: _jsx(PlusIcon, {}) }), "Launch a new Runtime\u2026"] }), _jsxs(ActionList.Item, { disabled: kernelLocation !== 'browser', selected: false, onSelect: () => {
+                                                setDialogCause(KernelDialogCause.Transfer);
+                                            }, title: "Transfer the state of the current Runtime to a new Remote Runtime.", children: [_jsx(ActionList.LeadingVisual, { children: _jsx(UnfoldIcon, {}) }), "Transfer state to a new Runtime\u2026"] })] })] }) })] }), multiServiceManager?.remote && dialogCause > 0 && (_jsx(KernelLauncherDialog, { dialogTitle: dialogCause === KernelDialogCause.Transfer
+                    ? 'Switch to a new Cloud Runtime'
+                    : undefined, manager: multiServiceManager.remote, onSubmit: handleCloseDialog, markdownParser: luminoServices[IMarkdownParser.name], sanitizer: luminoServices[ISanitizer.name], startKernel: dialogCause === KernelDialogCause.Transfer
+                    ? 'defer'
+                    : dialogCause === KernelDialogCause.New }))] }));
+}

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

@@ -0,0 +1,16 @@
+import { type IRuntimeOptions } from '../../api';
+export interface RuntimeTransfer {
+    /**
+     * Selected Kernel.
+     */
+    kernel: 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) 2023-2025 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 '../../api';
+import { IRuntimeDesc } from '../../api';
+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;