@datalayer/agent-runtimes 1.0.29 → 1.3.11

package/lib/components/code-sandboxes/CodeSandboxLauncher.js

@@ -1,8 +1,4 @@
 import { Fragment as _Fragment, 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, useEffect, useMemo, useState } from 'react';
 import { useIsMounted } from 'usehooks-ts';
 import { Button, FormControl, Spinner, Text, TextInput, ToggleSwitch, } from '@primer/react';
@@ -14,6 +10,8 @@ import { NO_RUNTIME_AVAILABLE_LABEL } from '@datalayer/core/lib/i18n';
 import { isCodeSandboxProviderAvailable } from './codeSandboxProviders';
 import { CodeSandboxVariant, codeSandboxVariantOf, codeSandboxVariantTitle, } from '../../models/CodeSandboxVariant';
 import { CodeSandboxEnvironmentSelect, } from './CodeSandboxEnvironmentSelect';
+import { codeSandboxEnvironmentOptions, codeSandboxEnvironmentVersion, firstLaunchableCodeSandboxEnvironment, libraryEnvironmentOf, } from './codeSandboxEnvironments';
+import { getEnvironmentPublication } from '../../api/runtimes/environments';
 import { getCodeSandboxGivenName, listCodeSandboxGivenNames, nextCodeSandboxGivenName, setCodeSandboxGivenName, } from './CodeSandboxNames';
 import { iamStore, runtimesStore, useCoreStore, useIAMStore, } from '../../state/substates';
 import { createRuntime as createRuntimeRecord } from '../../runtimes/actions';
@@ -45,7 +43,7 @@ const NOT_AVAILABLE_RETRIES = 5;
  * The launcher of a new code sandbox.
  */
 export function CodeSandboxLauncher(props) {
-    const { dialogTitle, kernelSnapshot, manager, onSubmit, markdownParser, sanitizer, upgradeSubscription, usageRoute = '/plans', submitLabel, startRuntime = true, } = props;
+    const { dialogTitle, kernelSnapshot, manager, onSubmit, markdownParser, sanitizer, upgradeSubscription, usageRoute = '/plans', submitLabel, startRuntime = true, libraryVersionUid, } = props;
     const hasExample = startRuntime === 'with-example';
     const shouldStartRuntime = startRuntime !== 'defer';
     const user = iamStore.getState().user;
@@ -59,7 +57,45 @@ export function CodeSandboxLauncher(props) {
      * below.
      */
     const jupyterAvailable = isCodeSandboxProviderAvailable('local', runtimesStore.getState().multiServiceManager);
-    const environments = manager.environments.get();
+    const listed = manager.environments.get();
+    /*
+     * A publication somebody else owns, which no listing of the viewer's holds
+     * (D-12, E2-19): read by its version uid, offered under *Library* beside
+     * the rest, priced by the rate the publication carries, and selected below,
+     * since it is what the reader came here to launch.
+     */
+    const [libraryEntry, setLibraryEntry] = useState();
+    const [libraryRefusal, setLibraryRefusal] = useState('');
+    useEffect(() => {
+        if (!libraryVersionUid) {
+            return undefined;
+        }
+        let current = true;
+        getEnvironmentPublication(iamStore.getState().token ?? '', libraryVersionUid, {}, runtimesStore.getState().runtimesUrl)
+            .then(publication => {
+            if (!current) {
+                return;
+            }
+            const entry = libraryEnvironmentOf(publication);
+            if (entry) {
+                setLibraryEntry(entry);
+            }
+            else {
+                setLibraryRefusal('This environment is no longer published, so it cannot be launched from the Library.');
+            }
+        })
+            .catch(() => {
+            if (current) {
+                setLibraryRefusal('This published environment could not be read, so it cannot be launched from here.');
+            }
+        });
+        return () => {
+            current = false;
+        };
+    }, [libraryVersionUid]);
+    const environments = useMemo(() => libraryEntry && !listed.some(entry => entry.name === libraryEntry.name)
+        ? [...listed, libraryEntry]
+        : listed, [listed, libraryEntry]);
     /*
      * The sandboxes of this Jupyter Server, offered beside those of the platform.
      *
@@ -91,27 +127,31 @@ export function CodeSandboxLauncher(props) {
         }));
     }, [jupyterAvailable]);
     const LOCAL_PREFIX = 'local:';
+    /** Who is looking, which is what tells your environments from your organizations'. */
+    const viewer = useMemo(() => ({ uid: user?.uid, handle: user?.handle }), [user]);
     /*
      * The choices of the dropdown: what the platform and the external
      * providers offer, then the kernelspecs of this Jupyter Server. Each says
      * whose machine it is — two entries called "GPU" are told apart by nothing
      * else.
+     *
+     * The environments come through `codeSandboxEnvironments`, so they read
+     * here exactly as they read in the picker: grouped as yours, your
+     * organizations' and the platform's, with the version and size class each
+     * runs, and disabled where there is nothing built to launch (E1-19).
      */
     const environmentOptions = useMemo(() => [
-        ...environments.map(spec => ({
-            key: spec.name,
-            title: spec.title || spec.name,
-            name: spec.name,
+        ...codeSandboxEnvironmentOptions(environments, viewer, spec => ({
             providerTitle: codeSandboxVariantTitle(codeSandboxVariantOf(spec?.owner)),
-            burningRate: spec.burning_rate,
         })),
         ...localSpecs.map(spec => ({
             key: `${LOCAL_PREFIX}${spec.name}`,
             title: spec.title || spec.name,
             name: spec.name,
             providerTitle: codeSandboxVariantTitle(CodeSandboxVariant.JupyterServer),
+            group: 'This Jupyter Server',
         })),
-    ], [environments, localSpecs]);
+    ], [environments, localSpecs, viewer]);
     const localSpecOf = (value) => value.startsWith(LOCAL_PREFIX)
         ? localSpecs.find(spec => spec.name === value.slice(LOCAL_PREFIX.length))
         : undefined;
@@ -128,7 +168,12 @@ export function CodeSandboxLauncher(props) {
     }
     const jupyterReactStore = useJupyterReactStore();
     const jupyterLabAdapter = jupyterReactStore.jupyterLabAdapter;
-    const [selection, setSelection] = useState((kernelSnapshot?.environment || environments[0]?.name) ?? '');
+    const [selection, setSelection] = useState(
+    // Never an environment that cannot be launched — one whose variant was
+    // never built — or the dialog would open on a choice it must refuse.
+    (kernelSnapshot?.environment ||
+        firstLaunchableCodeSandboxEnvironment(environments)?.name) ??
+        '');
     /*
      * Something is always selected.
      *
@@ -159,10 +204,21 @@ export function CodeSandboxLauncher(props) {
         ...listCodeSandboxGivenNames(),
     ], [manager]);
     const givenNameFor = useCallback((spec) => nextCodeSandboxGivenName(spec?.runtime?.givenNameTemplate || spec?.title || '', takenGivenNames()), [takenGivenNames]);
-    const [runtimeName, setRuntimeName] = useState(() => givenNameFor(environments[0]));
+    const [runtimeName, setRuntimeName] = useState(() => givenNameFor(firstLaunchableCodeSandboxEnvironment(environments)));
     // Whether the runtim name has been changed by the user or not
     const [hasCustomRuntimeName, setHasCustomRuntimeName] = useState(false);
-    const [userStorage, setUserStorage] = useState(false);
+    // The publication the reader came to launch, selected once it is read.
+    useEffect(() => {
+        if (!libraryEntry) {
+            return;
+        }
+        setSelection(libraryEntry.name);
+        if (!hasCustomRuntimeName) {
+            setRuntimeName(givenNameFor(libraryEntry));
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [libraryEntry]);
+    const [homeFolder, setHomeFolder] = useState(false);
     const [openExample, setOpenExample] = useState(false);
     const [waitingForRuntime, setWaitingForRuntime] = useState(false);
     const [error, setError] = useState();
@@ -231,6 +287,17 @@ export function CodeSandboxLauncher(props) {
             setError(undefined);
             setWaitingForRuntime(shouldStartRuntime);
             const spec = environments.find(s => s.name === selection);
+            /*
+             * The version the dropdown showed is the version that launches.
+             *
+             * A user environment's entry says "v3", and sending that pins it: a
+             * promotion made while this dialog was open cannot change what the
+             * person accepted. A platform environment has no version, and the
+             * request is then the one it has always been (PLAN_ENV.md, E1-19).
+             */
+            const environmentVersion = spec
+                ? codeSandboxEnvironmentVersion(spec)
+                : undefined;
             const desc = {
                 name: selection,
                 language: spec?.language ?? '',
@@ -242,8 +309,8 @@ export function CodeSandboxLauncher(props) {
             if (startRuntime === 'defer') {
                 desc.params['creditsLimit'] = creditsLimit;
             }
-            if (userStorage) {
-                desc.params['capabilities'] = ['user_storage'];
+            if (homeFolder) {
+                desc.params['capabilities'] = ['home-folder'];
             }
             let success = true;
             const provider = codeSandboxVariantOf(spec?.owner);
@@ -259,6 +326,7 @@ export function CodeSandboxLauncher(props) {
                 try {
                     await createRuntimeRecord({
                         environmentName: selection,
+                        environmentVersion,
                         type: 'notebook',
                         givenName: runtimeName,
                         creditsLimit,
@@ -276,7 +344,6 @@ export function CodeSandboxLauncher(props) {
                 }
             }
             else if (shouldStartRuntime) {
-                success = false;
                 let availableTrial = 1;
                 let retryDelay = NOT_AVAILABLE_INIT_RETRY;
                 // Should return success status.
@@ -284,10 +351,11 @@ export function CodeSandboxLauncher(props) {
                     try {
                         const connection = await manager.runtimesManager.startNew({
                             environmentName: selection,
+                            environmentVersion,
                             type: 'notebook',
                             givenName: runtimeName,
                             creditsLimit: creditsLimit,
-                            capabilities: userStorage ? ['user_storage'] : undefined,
+                            capabilities: homeFolder ? ['home-folder'] : undefined,
                             snapshot: kernelSnapshot?.id,
                         }, {
                             username: user?.handle,
@@ -368,7 +436,7 @@ export function CodeSandboxLauncher(props) {
         startRuntime,
         runtimeName,
         onSubmit,
-        userStorage,
+        homeFolder,
         openExample,
         jupyterLabAdapter,
         timeLimit,
@@ -418,7 +486,7 @@ export function CodeSandboxLauncher(props) {
                     event.preventDefault();
                     handleSubmitRuntime();
                 }
-            }, children: [_jsxs(FormControl, { disabled: !!kernelSnapshot?.environment || environments.length === 0, children: [_jsx(FormControl.Label, { children: "Environment" }), _jsx(CodeSandboxEnvironmentSelect, { disabled: !!kernelSnapshot?.environment || environments.length === 0, options: environmentOptions, selectedKey: selection, onSelect: handleSelectionChange }), _jsx(FormControl.Caption, { children: _jsx(_Fragment, { children: markdownParser ? (_jsx(Box, { sx: { img: { maxWidth: '100%' } }, children: _jsx(Markdown, { text: description, markdownParser: markdownParser, sanitizer: sanitizer }) })) : sanitizer ? (
+            }, children: [libraryRefusal ? (_jsx(Text, { as: "p", sx: { color: 'attention.fg' }, "data-testid": "library-refusal", children: libraryRefusal })) : null, _jsxs(FormControl, { disabled: !!kernelSnapshot?.environment || environments.length === 0, children: [_jsx(FormControl.Label, { children: "Environment" }), _jsx(CodeSandboxEnvironmentSelect, { disabled: !!kernelSnapshot?.environment || environments.length === 0, options: environmentOptions, selectedKey: selection, onSelect: handleSelectionChange }), _jsx(FormControl.Caption, { children: _jsx(_Fragment, { children: markdownParser ? (_jsx(Box, { sx: { img: { maxWidth: '100%' } }, children: _jsx(Markdown, { text: description, markdownParser: markdownParser, sanitizer: sanitizer }) })) : sanitizer ? (
                                 // The description of an environment carries markup. With no
                                 // parser to render it, the sanitizer of the application is
                                 // enough to show it as what it is rather than as its tags.
@@ -433,11 +501,15 @@ export function CodeSandboxLauncher(props) {
                 , { 
                     // A sandbox of this server costs nothing and starts at once: it has
                     // no time to reserve and no storage of the platform to mount.
-                    withReservation: !!startRuntime && !isLocalSelection, withUserStorage: !isLocalSelection, burningRate: burningRate, timeLimit: timeLimit, onTimeChange: setTimeLimit, max: effectiveMaxMinutes, disabled: outOfCredits, error: outOfCredits ? 'You must add credits to your account.' : undefined, addCredits: navigate
+                    withReservation: !!startRuntime && !isLocalSelection, withHomeFolder: !isLocalSelection, burningRate: burningRate, timeLimit: timeLimit, onTimeChange: setTimeLimit, max: effectiveMaxMinutes, 
+                    // Nothing to reserve or store until an environment is chosen.
+                    disabled: outOfCredits || !selection, storageDisabled: !selection, error: outOfCredits ? 'You must add credits to your account.' : undefined, addCredits: navigate
                         ? () => {
                             navigate(usageRoute);
                         }
-                        : undefined, userStorage: userStorage, onUserStorageToggle: () => setUserStorage(current => !current) }), _jsxs(FormControl, { sx: { paddingTop: '10px' }, children: [_jsx(FormControl.Label, { children: "Given Name" }), _jsx(TextInput, { name: "name", value: runtimeName, onChange: handleKernelNameChange, block: true })] }), hasExample &&
+                        : undefined, homeFolder: homeFolder, onHomeFolderToggle: () => setHomeFolder(current => !current) }), _jsxs(FormControl, { sx: { paddingTop: '10px' }, children: [_jsx(FormControl.Label, { children: "Given Name" }), _jsx(TextInput, { name: "name", value: runtimeName, onChange: handleKernelNameChange, 
+                            // A sandbox is named only once there is one to name.
+                            disabled: !selection, block: true })] }), hasExample &&
                     jupyterLabAdapter?.jupyterLab &&
                     !configuration.whiteLabel && (_jsxs(FormControl, { sx: { paddingTop: '10px' }, children: [_jsx(FormControl.Label, { id: "open-example-label", children: "Open example notebook" }), _jsx(ToggleSwitch, { disabled: !environments.find(spec => spec.name === selection)?.example, checked: openExample, size: "small", onClick: handleSwitchClick, "aria-labelledby": "open-example-label" })] })), error && (_jsx(FlashClosable, { variant: flashLevel, actions: navigate && upgradeSubscription && flashLevel === 'warning' ? (_jsx(Button, { onClick: handleUpgrade, title: 'Upgrade your subscription.', children: "Upgrade" })) : undefined, children: error }))] }) }));
 }

package/lib/components/code-sandboxes/CodeSandboxNames.js

@@ -2,10 +2,6 @@
  * Copyright (c) 2025-2026 Datalayer, Inc.
  * Distributed under the terms of the Modified BSD License.
  */
-/*
- * Copyright (c) 2023-2025 Datalayer, Inc.
- * Distributed under the terms of the Modified BSD License.
- */
 /**
  * The given name of a code sandbox of a Jupyter Server or of the browser.
  *
@@ -155,8 +151,13 @@ export function pruneCodeSandboxGivenNames(runningKernelIds) {
  */
 function asGivenName(base) {
     const stripped = (base ?? '')
-        // Pictographs, their skin tones, their joiners and their selectors.
-        .replace(/[\u{1F000}-\u{1FAFF}\u{2190}-\u{2BFF}\u{FE00}-\u{FE0F}\u{200D}]/gu, ' ')
+        /*
+         * Pictographs, their skin tones, their joiners and their selectors.
+         * Split into three alternatives rather than one class: a class whose next
+         * range starts on a combining mark (the variation selectors) reads to
+         * `no-misleading-character-class` as a base character followed by a mark.
+         */
+        .replace(/[\u{1F000}-\u{1FAFF}\u{2190}-\u{2BFF}]|[\u{FE00}-\u{FE0F}]|\u{200D}/gu, ' ')
         .replace(/\s+/g, ' ')
         .trim();
     return stripped || 'Code Sandbox';

package/lib/components/code-sandboxes/CodeSandboxPicker.js

@@ -1,8 +1,4 @@
 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, useMemo, useRef, useState, } from 'react';
 import { nullTranslator } from '@jupyterlab/translation';
 //import { kernelIcon } from '@jupyterlab/ui-components';
@@ -34,14 +30,30 @@ const RUNTIME_DISPLAY_NAME_MAX_LENGTH = 25;
  * "Assign a new Code Sandbox" and never among the ones already running.
  */
 function isRunningSandbox(desc) {
-    return !!desc.kernelId || !!desc.podName;
+    return !!desc.kernelId || !!desc.runtimeName;
 }
 /** How a sandbox is identified among the choices; see `dropdownDescs`. */
 function codeSandboxDescKey(desc) {
-    // The pod stands in for the kernel of a sandbox that has none — the ones
-    // of an external provider. Without it two Modal sandboxes of the same
-    // environment answer to one key and the list shows a single row.
-    return `${desc.location}:${desc.kernelId ?? desc.podName ?? desc.name}`;
+    // The runtime uid, then the pod, stands in for the kernel of a sandbox that
+    // does not have one yet. Without that identity all Daytona sandboxes of the
+    // same environment answer to one key.
+    return `${desc.location}:${desc.kernelId ?? desc.id ?? desc.runtimeName ?? desc.name}`;
+}
+/** The identifier shown beside a running sandbox. */
+function codeSandboxDisplayId(desc) {
+    return desc.kernelId ?? desc.id ?? desc.runtimeName;
+}
+/** Whether two descriptions refer to the same choice. */
+function isSameCodeSandbox(left, right) {
+    if (!right) {
+        return false;
+    }
+    if (left.runtimeName && right.runtimeName) {
+        return left.runtimeName === right.runtimeName;
+    }
+    const sameLocation = left.location === right.location ||
+        (isRuntimeRemote(left.location) && isRuntimeRemote(right.location));
+    return sameLocation && codeSandboxDescKey(left) === codeSandboxDescKey(right);
 }
 /**
  * The picker of a code sandbox: what runs already, and what could run.
@@ -108,10 +120,15 @@ export function CodeSandboxPicker(props) {
         descs.filter(isRunningSandbox),
     ])
         .filter(([, descs]) => descs.length > 0), [groupedRuntimeDescs]);
-    const environmentOnlyOptions = useMemo(() => dropdownOptions.filter(option => {
+    const environmentOnlyOptions = useMemo(() => dropdownOptions
+        .filter(option => {
         const desc = dropdownDescs.get(option.key);
         return !desc || !isRunningSandbox(desc);
-    }), [dropdownDescs, dropdownOptions]);
+    })
+        // The running sandboxes are the radio column beside this; the dropdown
+        // then lists only environments to start, so it needs no group heading
+        // of its own ("Assign a new Code Sandbox" already labels the control).
+        .map(option => ({ ...option, group: undefined })), [dropdownDescs, dropdownOptions]);
     const radioSections = (entries) => (_jsx(RadioGroup, { name: "kernel-options", "aria-labelledby": "kernel-options", children: entries.map(([group, runtimeDescs]) => (_jsxs(Box, { children: [_jsx(Box, { as: "h4", sx: {
                         /*
                          * The type of a form label, not of a heading.
@@ -132,22 +149,20 @@ export function CodeSandboxPicker(props) {
                         fontSize: 'var(--text-body-size-medium, 0.875rem)',
                         fontWeight: 'var(--base-text-weight-semibold, 600)',
                     }, children: group }), runtimeDescs.map(k => {
+                    const choiceKey = codeSandboxDescKey(k);
+                    const displayId = codeSandboxDisplayId(k);
                     return (
                     // A kernel identifies a runtime that already runs; an
                     // environment to start one in has none, and is named
                     // by where it runs and what it runs.
-                    _jsxs(Box, { title: k.name, children: [_jsxs(FormControl, { children: [_jsx(Radio, { value: k.kernelId, onChange: () => {
+                    _jsxs(Box, { title: k.name, children: [_jsxs(FormControl, { children: [_jsx(Radio, { value: choiceKey, onChange: () => {
                                             setRuntimeDesc(k);
-                                        }, checked: (k.location === runtimeDesc?.location ||
-                                            (isRuntimeRemote(k.location) &&
-                                                isRuntimeRemote(runtimeDesc?.location ?? 'local'))) &&
-                                            (k.kernelId ?? k.name) ===
-                                                (runtimeDesc?.kernelId ?? runtimeDesc?.name) }), _jsx(FormControl.Label, { children: _jsxs(Box, { display: "flex", sx: { alignItems: 'baseline' }, children: [_jsx(Box, { children: k.displayName }), k.kernelId && (_jsx(Text, { sx: {
+                                        }, checked: isSameCodeSandbox(k, runtimeDesc) }), _jsx(FormControl.Label, { children: _jsxs(Box, { display: "flex", sx: { alignItems: 'baseline' }, children: [_jsx(Box, { children: k.displayName }), displayId && (_jsx(Text, { sx: {
                                                         ml: 2,
                                                         fontSize: 0,
                                                         color: 'fg.muted',
-                                                        fontFamily: 'mono'
-                                                    }, title: k.kernelId, children: k.kernelId.slice(0, 8) })), k.kernelId && k.location === 'remote' && (_jsx(Box, { ml: 3, mt: 1, children: _jsx(CreditsIndicator, { kernelId: k.kernelId, serviceManager: multiServiceManager.remote }, "credits-indicator") }))] }) }), _jsx(FormControl.Caption, { children: _jsxs(LabelGroup, { sx: { marginTop: 1 }, children: [_jsx(Label, { variant: "secondary", children: k.name }), k.provider && (_jsx(Label, { variant: "accent", sx: { marginLeft: 1 }, children: codeSandboxVariantTitle(k.provider) })), _jsx(Label, { variant: "secondary", sx: { marginLeft: 1 }, children: k.location }), k.burningRate && (_jsxs(Label, { variant: "sponsors", sx: { marginLeft: 1 }, children: [k.burningRate, " credits/second"] })), k.gpu && (_jsx(Label, { variant: "success", sx: { marginLeft: 1 }, children: "GPU" }))] }) })] }), _jsx(ActionList.Divider, {})] }, `${k.location}:${k.kernelId ?? k.name}`));
+                                                        fontFamily: 'mono',
+                                                    }, title: displayId, children: displayId.slice(0, 8) })), k.kernelId && k.location === 'remote' && (_jsx(Box, { ml: 3, mt: 1, children: _jsx(CreditsIndicator, { kernelId: k.kernelId, serviceManager: multiServiceManager.remote }, "credits-indicator") }))] }) }), _jsx(FormControl.Caption, { children: _jsxs(LabelGroup, { sx: { marginTop: 1 }, children: [_jsx(Label, { variant: "secondary", children: k.name }), k.provider && (_jsx(Label, { variant: "accent", sx: { marginLeft: 1 }, children: codeSandboxVariantTitle(k.provider) })), _jsx(Label, { variant: "secondary", sx: { marginLeft: 1 }, children: k.location }), k.burningRate && (_jsxs(Label, { variant: "sponsors", sx: { marginLeft: 1 }, children: [k.burningRate, " credits/second"] })), k.gpu && (_jsx(Label, { variant: "success", sx: { marginLeft: 1 }, children: "GPU" }))] }) })] }), _jsx(ActionList.Divider, {})] }, choiceKey));
                 })] }, group))) }));
     const trans = useMemo(() => (translator ?? nullTranslator).load('jupyterlab'), [translator]);
     const [defaultSet, setDefaultSet] = useState(false);
@@ -220,17 +235,36 @@ export function CodeSandboxPicker(props) {
         }
         if (sessionContext && groupedRuntimeDescs) {
             const kernelId = sessionContext.session?.kernel?.id;
-            if (kernelId) {
+            /*
+             * An external sandbox is bound by its POD, not a kernel of this platform.
+             *
+             * Its descriptor carries the pod and — until a kernel of the platform is
+             * ever attached — an empty kernel id, and the session it binds stands on
+             * the pod as its `location`. Matching only on the kernel id therefore
+             * missed it: the picker fell back to the local kernel the notebook never
+             * ran on, opening on "Python 3" while the toolbar rightly showed the
+             * sandbox. So the current sandbox is matched on the pod as well, and the
+             * remote descriptors — which arrive late — are waited for before the
+             * choice is allowed to settle on anything else.
+             */
+            const location = sessionContext.location;
+            const remoteBound = !!location && isRuntimeRemote(location);
+            const matchesCurrent = (desc) => (!!kernelId && desc.kernelId === kernelId) ||
+                (!!desc.runtimeName && !!location && desc.runtimeName === location);
+            if (kernelId || remoteBound) {
+                if (remoteBound && !remoteModelsReady) {
+                    return;
+                }
                 let matched = false;
-                Object.entries(groupedRuntimeDescs).forEach(([group, runtimeDescs]) => {
+                Object.values(groupedRuntimeDescs).forEach(runtimeDescs => {
                     runtimeDescs.forEach(runtimeDesc => {
-                        if (runtimeDesc.kernelId === kernelId) {
+                        if (matchesCurrent(runtimeDesc)) {
                             matched = true;
                             setRuntimeDesc(runtimeDesc);
                         }
                     });
                 });
-                if (!matched) {
+                if (!matched && kernelId) {
                     if (!remoteModelsReady) {
                         return;
                     }
@@ -244,8 +278,8 @@ export function CodeSandboxPicker(props) {
                             kernelId,
                             language: spec.language,
                             displayName: sessionContext.kernelDisplayName,
-                            location: sessionContext.location ??
-                                'local',
+                            location: location ?? 'local',
+                            runtimeName: remoteBound ? location : undefined,
                         });
                     }
                 }
@@ -300,7 +334,7 @@ export function CodeSandboxPicker(props) {
      */
     const [givenName, setGivenName] = useState('');
     const givenNameFor = useRef(undefined);
-    const [userStorage, setUserStorage] = useState(false);
+    const [homeFolder, setHomeFolder] = useState(false);
     const asksForNewSandbox = withNewSandboxControls || !!onTransferChange;
     useEffect(() => {
         if (asksForNewSandbox) {
@@ -312,7 +346,12 @@ export function CodeSandboxPicker(props) {
             .get()
             .find(env => env.name === runtimeDesc?.name)?.burning_rate;
     const allowance = useNewCodeSandboxAllowance(resolvedBurningRate);
-    const isNewSandbox = !!runtimeDesc && !runtimeDesc.kernelId;
+    // New means an environment to start, not a sandbox already running. An
+    // external sandbox runs with a pod but no kernel of its own, so keying
+    // "new" on the kernel alone misread it as new — and a new remote sandbox
+    // the account cannot yet price is answered with nothing, which is why
+    // assigning an existing Daytona did nothing.
+    const isNewSandbox = !!runtimeDesc && !isRunningSandbox(runtimeDesc);
     // Offer a name for what was just picked, and leave it alone afterwards: the
     // key is the thing picked, so re-picking the same one keeps what was typed.
     const pickedKey = isNewSandbox
@@ -375,28 +414,40 @@ export function CodeSandboxPicker(props) {
                         ? `${runtimeDesc.location}-${runtimeDesc.name}`
                         : runtimeDesc.name,
                     id: runtimeDesc.kernelId,
+                    // The pod names a sandbox that has no kernel of its own — an
+                    // external one — so the session can bind it through the proxy.
+                    runtime_name: runtimeDesc.runtimeName,
                     // The name the sandbox is given, carried with the choice.
                     //
                     // Everything else about the pick travelled in this object and the
                     // name did not, so whoever created the sandbox had nothing to name
                     // it with and fell back to the kernelspec: the launcher honoured
                     // what was typed, the picker silently dropped it.
+                    //
+                    // Two readers, two fields: a sandbox of a server is named from
+                    // `displayName`, a runtime of the platform is started with
+                    // `givenName`. A new remote sandbox — a Daytona among them — read
+                    // the second, which nothing filled, and came up "Code Sandbox".
+                    // Both carry the name now: what the user typed, or the title of the
+                    // environment it runs.
                     displayName: runtimeDesc.displayName,
+                    givenName: givenName || runtimeDesc.displayName,
                     creditsLimit,
-                    capabilities: userStorage ? ['user_storage'] : undefined,
+                    capabilities: homeFolder ? ['home-folder'] : undefined,
                 }
                 : null,
             selectedVariables,
         });
     }, [
         allowance,
+        givenName,
         isNewSandbox,
         onTransferChange,
         resolvedBurningRate,
         runtimeDesc,
         selectedVariables,
         timeLimit,
-        userStorage,
+        homeFolder,
     ]);
     // For cell using submenu instead of group would be nice unfortunately the feature
     // is not yet implemented in the component there has been a not-great demo story.
@@ -410,8 +461,9 @@ export function CodeSandboxPicker(props) {
                             icon: () => (_jsx("span", { className: "dla-Cell-runtime-icon", children: _jsx(CpuIcon, {}) })), "aria-label": trans.__('Assign a Runtime to the Cell.'), title: trans.__('Assign a Runtime to the Cell.'), size: "small", variant: "invisible" }) })) : (_jsxs(ActionMenu.Button, { variant: "default", disabled: disabled || groupedRuntimeDescs === null, children: [_jsx(Text, { fontWeight: 'bold', children: trans.__('Runtime:') }), ' ' + (runtimeDesc?.displayName ?? trans.__('No Runtime'))] })), _jsx(ActionMenu.Overlay, { ...overlayProps, width: "medium", sx: { overflowY: 'auto' }, side: variant === 'cell' ? 'outside-left' : 'outside-right', children: _jsxs(ActionList, { selectionVariant: "single", children: [variant === 'cell' && (_jsxs(ActionList.Item, { selected: runtimeDesc === undefined, onSelect: () => {
                                         setRuntimeDesc(undefined);
                                     }, children: [preference?.location && (_jsx(ActionList.LeadingVisual, { children: preference.location === 'local' ? (_jsx(LaptopSimpleIcon, {})) : preference.location === 'browser' ? (_jsx(BrowserIcon, {})) : (_jsx(CloudUploadIcon, {})) })), trans.__('Assign the Notebook Runtime')] }, 'null')), !!preActions && preActions, Object.entries(groupedRuntimeDescs ?? {}).map(([group, runtimeDescs]) => (_jsxs(ActionList.Group, { children: [_jsx(ActionList.GroupHeading, { children: group }), runtimeDescs.map(candidateRuntimeDesc => {
-                                            const annotation = candidateRuntimeDesc.podName
-                                                ? ` - ${candidateRuntimeDesc.podName.split('-', 2).reverse()[0]}`
+                                            const choiceKey = codeSandboxDescKey(candidateRuntimeDesc);
+                                            const annotation = candidateRuntimeDesc.runtimeName
+                                                ? ` - ${candidateRuntimeDesc.runtimeName}`
                                                 : candidateRuntimeDesc.kernelId
                                                     ? ` - ${candidateRuntimeDesc.kernelId}`
                                                     : '';
@@ -420,16 +472,10 @@ export function CodeSandboxPicker(props) {
                                                 RUNTIME_DISPLAY_NAME_MAX_LENGTH
                                                 ? candidateRuntimeDesc.displayName.slice(0, RUNTIME_DISPLAY_NAME_MAX_LENGTH) + '…'
                                                 : (candidateRuntimeDesc.displayName ?? '');
-                                            return (_jsxs(ActionList.Item, { title: fullDisplayName, selected: (candidateRuntimeDesc.location ===
-                                                    runtimeDesc?.location ||
-                                                    (isRuntimeRemote(candidateRuntimeDesc.location) &&
-                                                        isRuntimeRemote(runtimeDesc?.location ?? 'local'))) &&
-                                                    (candidateRuntimeDesc.kernelId ??
-                                                        candidateRuntimeDesc.name) ===
-                                                        (runtimeDesc?.kernelId ?? runtimeDesc?.name), onSelect: () => {
+                                            return (_jsxs(ActionList.Item, { title: fullDisplayName, selected: isSameCodeSandbox(candidateRuntimeDesc, runtimeDesc), onSelect: () => {
                                                     setRuntimeDesc(candidateRuntimeDesc);
                                                 }, children: [_jsx(ActionList.LeadingVisual, { children: candidateRuntimeDesc.location === 'local' ? (_jsx(LaptopSimpleIcon, {})) : candidateRuntimeDesc.location === 'browser' ? (_jsx(BrowserIcon, {})) : (_jsx(CloudUploadIcon, {})) }), displayName + annotation.slice(0, 10), _jsxs(ActionList.TrailingVisual, { children: [candidateRuntimeDesc.name && (_jsx(Label, { size: "small", variant: "secondary", children: candidateRuntimeDesc.name })), ' ', candidateRuntimeDesc
-                                                                .provider && (_jsx(Label, { size: "small", variant: "accent", children: codeSandboxVariantTitle(candidateRuntimeDesc.provider) }))] })] }, candidateRuntimeDesc.name));
+                                                                .provider && (_jsx(Label, { size: "small", variant: "accent", children: codeSandboxVariantTitle(candidateRuntimeDesc.provider) }))] })] }, choiceKey));
                                         })] }, group))), !!postActions && (_jsxs(_Fragment, { children: [_jsx(ActionList.Divider, {}), postActions] }))] }) })] })) : display === 'dropdown' ? (
             /*
              * Section for the dropdown display.
@@ -439,11 +485,12 @@ export function CodeSandboxPicker(props) {
              * nine rows of radio buttons before anything else on the dialog can
              * be read; closed, it is one line.
              */
-            _jsxs(_Fragment, { children: [defaultSet && sandboxLayout === 'separated' &&
+            _jsxs(_Fragment, { children: [defaultSet &&
+                        sandboxLayout === 'separated' &&
                         runningEntries.length > 0 &&
                         radioSections(runningEntries), defaultSet && (
                     // Room below: the controls of a new sandbox follow, and the
-                    // toggle of the user storage sat against the dropdown.
+                    // toggle of the home folder sat against the dropdown.
                     _jsxs(FormControl, { sx: { marginBottom: 4 }, children: [_jsx(FormControl.Label, { children: sandboxLayout === 'separated'
                                     ? 'Assign a new Code Sandbox'
                                     : 'Environment' }), _jsx(CodeSandboxEnvironmentSelect, { disabled: disabled, options: sandboxLayout === 'separated'
@@ -476,6 +523,6 @@ export function CodeSandboxPicker(props) {
                         // the name travels with it, rather than beside it.
                         setRuntimeDesc({ ...runtimeDesc, displayName: value });
                     }
-                }, userStorage: userStorage, onUserStorageToggle: () => setUserStorage(current => !current) })), variables.available && (_jsx(CodeSandboxVariables, { selectedVariables: variables.selected, setSelectVariable: variables.setSelected, transferVariables: variables.transfer, setTransferVariable: variables.setTransfer, kernelVariables: variables.variables, translator: translator }))] }));
+                }, homeFolder: homeFolder, onHomeFolderToggle: () => setHomeFolder(current => !current) })), variables.available && (_jsx(CodeSandboxVariables, { selectedVariables: variables.selected, setSelectVariable: variables.setSelected, transferVariables: variables.transfer, setTransferVariable: variables.setTransfer, kernelVariables: variables.variables, translator: translator }))] }));
 }
 export default CodeSandboxPicker;

package/lib/components/code-sandboxes/CodeSandboxPickerCell.d.ts

@@ -1,3 +1,4 @@
+import type { JSX } from 'react';
 import { ISessionContext } from '@jupyterlab/apputils';
 import { CodeCellModel } from '@jupyterlab/cells';
 import type { IMarkdownParser, IRenderMime } from '@jupyterlab/rendermime';

package/lib/components/code-sandboxes/CodeSandboxPickerCell.js

@@ -1,8 +1,4 @@
 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, useMemo, useState } from 'react';
 import { nullTranslator } from '@jupyterlab/translation';
 import { ActionList } from '@primer/react';

package/lib/components/code-sandboxes/CodeSandboxReservationControl.d.ts

@@ -1,3 +1,4 @@
+import type { JSX } from 'react';
 /**
  * Maximal time reservable for a runtime in minutes.
  *

package/lib/components/code-sandboxes/CodeSandboxReservationControl.js

@@ -1,11 +1,7 @@
-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 { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 import { FormControl, IconButton, Text, TextInput } from '@primer/react';
 import { Box } from '@datalayer/primer-addons';
-import { PlusIcon } from '@primer/octicons-react';
+import { CreditCardIcon } from '@primer/octicons-react';
 import { Slider } from '@datalayer/primer-addons';
 /**
  * Maximal time reservable for a runtime in minutes.
@@ -45,5 +41,7 @@ export function CodeSandboxReservationControl(props) {
                     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: displayedTime, onChange: handleTimeChange, disabled: disabled, label: "", displayValue: false }), _jsx(TextInput, { type: "number", step: "1", min: "1", max: max, disabled: disabled, value: displayedTime.toFixed(2), onChange: handleTimeChange }), (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_CODE_SANDBOX_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, {}));
+                }, children: [_jsx(Slider, { step: 1, min: 1, max: max, value: displayedTime, onChange: handleTimeChange, disabled: disabled, label: "", displayValue: false }), _jsx(TextInput, { type: "number", step: "1", min: "1", max: max, disabled: disabled, value: displayedTime.toFixed(2), onChange: handleTimeChange }), (max === 0 || max > Number.EPSILON) && (_jsxs(_Fragment, { children: [_jsx(Text, { children: max < requestedMax
+                                    ? `out of ${max} minutes`
+                                    : `out of ${max} available minutes` }), addCredits && (_jsx(IconButton, { icon: CreditCardIcon, "aria-label": "Check your Plan", variant: "invisible", onClick: () => addCredits() }))] }))] }), _jsxs(FormControl.Caption, { children: ["Maximum execution time that can be consumed by the runtime. It must be less than", ' ', (MAXIMAL_CODE_SANDBOX_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/code-sandboxes/CodeSandboxTransfer.d.ts

@@ -11,6 +11,11 @@ export interface CodeSandboxTransfer {
     runtime: Partial<Omit<IRuntimeOptions, 'kernelType'> & {
         id: string;
         displayName: string;
+        /**
+         * The pod of an external sandbox (Daytona, E2B), which has no kernel of
+         * its own — the session binds it through the runtimes proxy by this.
+         */
+        runtime_name: string;
     }> | null;
     /**
      * List of selected variables

package/lib/components/code-sandboxes/CodeSandboxUtils.d.ts

@@ -1,12 +1,24 @@
 import { SessionContext } from '@jupyterlab/apputils';
 import { ITranslator } from '@jupyterlab/translation';
 import { IMultiServiceManager } from '../../runtimes';
-import { IRuntimeDesc } from '../../models';
+import { IRuntimeDesc, type IDatalayerEnvironment } from '../../models';
 import { CodeSandboxVariant } from '../../models/CodeSandboxVariant';
 export type IDatalayerCodeSandboxDesc = IRuntimeDesc & {
     gpu?: string;
     /** The provider the environment belongs to — see `CodeSandboxVariant`. */
     provider?: CodeSandboxVariant;
+    /**
+     * The listing entry a NEW sandbox would be started from, carried whole.
+     *
+     * What the picker has to say about an environment — whose it is, which
+     * version it launches, the class that prices it, whether anything was built
+     * for this variant — is decided by the rules in `codeSandboxEnvironments`,
+     * and they read the entry. Copying a field at a time here is how the
+     * launcher and the picker came to disagree about the same environment
+     * (PLAN_ENV.md, E1-19). Absent on a sandbox that already runs and on a
+     * kernelspec of a server or of the browser.
+     */
+    environment?: IDatalayerEnvironment;
 };
 /**
  * Create the grouped runtime descriptions.