@datalayer/agent-runtimes 1.0.21 → 1.0.26

package/lib/components/{runtimes/RuntimeReservationControl.js → code-sandboxes/CodeSandboxReservationControl.js}

@@ -12,13 +12,20 @@ import { Slider } from '@datalayer/primer-addons';
  *
  * TODO this should be configurable
  */
-export const MAXIMAL_RUNTIME_TIME_RESERVATION_MINUTES = 24 * 60;
+export const MAXIMAL_CODE_SANDBOX_TIME_RESERVATION_MINUTES = 24 * 60;
 /**
  * Runtime reservation control
  */
-export function RuntimeReservationControl(props) {
+export function CodeSandboxReservationControl(props) {
     const { addCredits, burningRate, disabled, error, label, max: maxProps, onTimeChange, time, } = props;
-    const max = Math.max(1, Math.min(maxProps, MAXIMAL_RUNTIME_TIME_RESERVATION_MINUTES));
+    // The caller computes its maximum from the credits and the burning rate of
+    // an environment, either of which may not be known yet — and a slider given
+    // `NaN` renders nothing but warnings. Fall back to what a reservation may
+    // hold in any case.
+    const requestedMax = Number.isFinite(maxProps)
+        ? maxProps
+        : MAXIMAL_CODE_SANDBOX_TIME_RESERVATION_MINUTES;
+    const max = Math.max(1, Math.min(requestedMax, MAXIMAL_CODE_SANDBOX_TIME_RESERVATION_MINUTES));
     const displayedTime = Number.isFinite(time)
         ? Math.min(max, Math.max(1, time))
         : 1;
@@ -38,5 +45,5 @@ export function RuntimeReservationControl(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_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, {}));
+                }, 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, {}));
 }

package/lib/components/{runtimes/RuntimeTransfer.d.ts → code-sandboxes/CodeSandboxTransfer.d.ts}

@@ -1,5 +1,5 @@
 import { type IRuntimeOptions } from '../../runtimes';
-export interface RuntimeTransfer {
+export interface CodeSandboxTransfer {
     /**
      * Selected Kernel.
      */

package/lib/components/{runtimes/RuntimeUtils.d.ts → code-sandboxes/CodeSandboxUtils.d.ts}

@@ -2,14 +2,14 @@ import { SessionContext } from '@jupyterlab/apputils';
 import { ITranslator } from '@jupyterlab/translation';
 import { IMultiServiceManager } from '../../runtimes';
 import { IRuntimeDesc } from '../../models';
-export type IDatalayerRuntimeDesc = IRuntimeDesc & {
+export type IDatalayerCodeSandboxDesc = 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[];
+export declare function getGroupedCodeSandboxDescs(multiServiceManager: IMultiServiceManager, kernelId?: string, translator?: ITranslator, filterKernels?: (desc: IDatalayerCodeSandboxDesc) => boolean, variant?: 'document' | 'cell'): {
+    [g: string]: IDatalayerCodeSandboxDesc[];
 } | undefined;
 /**
  * Get the default kernel name given a selector.

package/lib/components/{runtimes/RuntimeUtils.js → code-sandboxes/CodeSandboxUtils.js}

@@ -10,23 +10,25 @@ const ASSIGN_EXISTING_RUNTIME_LABEL = 'Assign an existing Runtime';
 /**
  * Create the grouped runtime descriptions.
  */
-export function getGroupedRuntimeDescs(multiServiceManager, kernelId, translator, filterKernels = () => true, variant) {
+export function getGroupedCodeSandboxDescs(multiServiceManager, kernelId, translator, filterKernels = () => true, variant) {
     translator = translator ?? nullTranslator;
     const trans = translator.load('jupyterlab');
+    // The specifications land asynchronously, and a runtime that already runs
+    // is listed with or without them: what a kernel needs to be picked is its
+    // identifier, the specification only names it. Only the environments to
+    // start a new runtime in come from the specifications, and they wait.
     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])
+        .filter(session => session.kernel && session.kernel.id !== kernelId)
         .map(session => {
-        const spec = specs.kernelspecs[session.kernel.name];
+        const spec = specs?.kernelspecs[session.kernel.name];
         return {
             kernelId: session.kernel.id,
-            name: spec.name,
-            language: spec.language,
+            name: spec?.name ?? session.kernel.name,
+            language: spec?.language ?? '',
             displayName: session.name || PathExt.basename(session.path),
             location: 'local',
         };
@@ -34,12 +36,13 @@ export function getGroupedRuntimeDescs(multiServiceManager, kernelId, translator
         .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];
+        // The browser specifications load on their own schedule.
+        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,
+            name: spec?.name ?? session.kernel.name,
+            language: spec?.language ?? '',
             displayName: session.name || PathExt.basename(session.path),
             location: 'browser',
         };
@@ -50,12 +53,12 @@ export function getGroupedRuntimeDescs(multiServiceManager, kernelId, translator
     const runningKernels = Array.from(multiServiceManager.local.kernels.running())
         .filter(k => !listedAsSession.includes(k.id))
         .map(k => {
-        const spec = specs.kernelspecs[k.name];
+        const spec = specs?.kernelspecs[k.name];
         return {
             kernelId: k.id,
-            name: spec.name,
-            language: spec.language,
-            displayName: spec.display_name,
+            name: spec?.name ?? k.name,
+            language: spec?.language ?? '',
+            displayName: spec?.display_name ?? k.name,
             location: 'local',
         };
     })
@@ -78,17 +81,30 @@ export function getGroupedRuntimeDescs(multiServiceManager, kernelId, translator
         .concat(Array.from(multiServiceManager.browser?.kernels.running() ?? [])
         .filter(k => !listedAsSession.includes(k.id))
         .map(k => {
-        const spec = multiServiceManager.browser.kernelspecs.specs.kernelspecs[k.name];
+        const spec = multiServiceManager.browser?.kernelspecs.specs?.kernelspecs[k.name];
         return {
             kernelId: k.id,
-            name: spec.name,
-            language: spec.language,
-            displayName: spec.display_name,
+            name: spec?.name ?? k.name,
+            language: spec?.language ?? '',
+            displayName: spec?.display_name ?? k.name,
             location: 'browser',
         };
     }))
         .filter(filterKernels);
     runningSessions.push(...runningKernels);
+    // The sources overlap — a kernel of a session, a manager standing in for
+    // another — and a runtime listed twice would be picked twice.
+    const seen = new Set();
+    const distinctRunning = runningSessions.filter(desc => {
+        const key = `${desc.location}:${desc.kernelId ?? desc.name}`;
+        if (seen.has(key)) {
+            return false;
+        }
+        seen.add(key);
+        return true;
+    });
+    runningSessions.length = 0;
+    runningSessions.push(...distinctRunning);
     if (runningSessions.length) {
         const key = variant === 'cell'
             ? ASSIGN_EXISTING_REMOTE_RUNTIME_LABEL
@@ -96,7 +112,7 @@ export function getGroupedRuntimeDescs(multiServiceManager, kernelId, translator
         kernels[key] = runningSessions;
     }
     // Environments.
-    const environments = Object.values(specs.kernelspecs)
+    const environments = Object.values(specs?.kernelspecs ?? {})
         .filter(spec => !!spec)
         .map(spec => ({
         name: spec.name,

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

@@ -0,0 +1,71 @@
+import { ReactElement } from 'react';
+import { ISessionContext } from '@jupyterlab/apputils';
+import { ITranslator } from '@jupyterlab/translation';
+import type { IRuntimeDesc } from '../../models';
+/** What {@link useCodeSandboxVariablesTransfer} answers. */
+export interface ICodeSandboxVariablesTransfer {
+    /**
+     * Whether carrying variables over is possible at all.
+     *
+     * Both ends must speak a language the snippets know how to serialize: the
+     * sandbox the variables come from, and the one they would go to.
+     */
+    available: boolean;
+    /** The variables of the current sandbox, by name and type. */
+    variables?: {
+        [name: string]: string;
+    };
+    /** Those the user chose to carry over. */
+    selected: string[];
+    setSelected: (names: string[]) => void;
+    /** Whether the user asked for the transfer at all. */
+    transfer: boolean;
+    setTransfer: (value: boolean) => void;
+}
+/**
+ * The variables of the current sandbox, and which of them to carry over.
+ *
+ * Listing them runs code in the sandbox — the snippet that names them — so it
+ * is deferred until the user asks for the transfer, and done once.
+ *
+ * @param sessionContext The session the variables are read from
+ * @param target The sandbox they would be carried to
+ * @param enabled Whether the transfer is offered at all
+ */
+export declare function useCodeSandboxVariablesTransfer(sessionContext: ISessionContext | undefined, target: IRuntimeDesc | undefined, enabled?: boolean): ICodeSandboxVariablesTransfer;
+/**
+ * {@link CodeSandboxVariables} properties
+ */
+export interface ICodeSandboxVariablesProps {
+    /**
+     * 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 CodeSandboxVariables(props: ICodeSandboxVariablesProps): ReactElement;

package/lib/components/{runtimes/RuntimeVariables.js → code-sandboxes/CodeSandboxVariables.js}

@@ -3,16 +3,91 @@ 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 { useCallback, useMemo, useState } 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';
+import { JSONExt } from '@lumino/coreutils';
+import { KernelExecutor } from '@datalayer/jupyter-react';
+import { RuntimeSnippetsFacade } from '../../jupyter';
+/**
+ * The variables of the current sandbox, and which of them to carry over.
+ *
+ * Listing them runs code in the sandbox — the snippet that names them — so it
+ * is deferred until the user asks for the transfer, and done once.
+ *
+ * @param sessionContext The session the variables are read from
+ * @param target The sandbox they would be carried to
+ * @param enabled Whether the transfer is offered at all
+ */
+export function useCodeSandboxVariablesTransfer(sessionContext, target, enabled = true) {
+    const [variables, setVariables] = useState();
+    const [selected, setSelectedState] = useState([]);
+    const [transfer, setTransferState] = useState(false);
+    const [listed, setListed] = useState(false);
+    const sourceLanguage = sessionContext?.session?.kernel?.name && sessionContext.specsManager.specs
+        ? sessionContext.specsManager.specs.kernelspecs[sessionContext.session.kernel.name]?.language
+        : undefined;
+    const available = enabled &&
+        RuntimeSnippetsFacade.supports(sourceLanguage ?? '') &&
+        RuntimeSnippetsFacade.supports(target?.language ?? '');
+    const list = useCallback(async () => {
+        if (listed) {
+            return;
+        }
+        setListed(true);
+        const connection = sessionContext?.session?.kernel;
+        const spec = connection &&
+            sessionContext?.specsManager.specs?.kernelspecs[connection.model.name];
+        if (!connection || !spec) {
+            setVariables({});
+            return;
+        }
+        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) {
+            setVariables({});
+            return;
+        }
+        // The payload comes quoted, as the representation of a string.
+        const listedVariables = JSON.parse(content.slice(1, content.length - 1));
+        setVariables(listedVariables);
+        // Everything is carried over unless the user says otherwise.
+        setSelectedState(Object.keys(listedVariables ?? {}));
+    }, [listed, sessionContext]);
+    const setSelected = useCallback((names) => {
+        setSelectedState(current => JSONExt.deepEqual(current, names) ? current : names);
+    }, [setSelectedState]);
+    const setTransfer = useCallback((value) => {
+        setTransferState(current => {
+            if (current === value) {
+                return current;
+            }
+            if (value) {
+                list().catch(reason => {
+                    console.error('Failed to list the variables of the sandbox', reason);
+                    setListed(false);
+                });
+            }
+            return value;
+        });
+    }, [list]);
+    return {
+        available,
+        variables,
+        selected: available && transfer ? selected : [],
+        setSelected,
+        transfer,
+        setTransfer,
+    };
+}
 /**
  * Runtime variables selector component.
  */
-export function RuntimeVariables(props) {
+export function CodeSandboxVariables(props) {
     const { className, translator, selectedVariables, setSelectVariable, transferVariables, setTransferVariable, kernelVariables, } = props;
     const trans = useMemo(() => (translator ?? nullTranslator).load('jupyterlab'), [translator]);
     const nRows = Object.keys(kernelVariables ?? {}).length;

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

@@ -0,0 +1,42 @@
+/** What the account allows for a new sandbox of a given burning rate. */
+export interface INewCodeSandboxAllowance {
+    /** Minutes the available credits pay for; undefined without a rate. */
+    maxFromCredits?: number;
+    /** The ceiling offered by the reservation control. */
+    effectiveMaxMinutes: number;
+    /** Whether a paid start is impossible: no runs left and no credits. */
+    outOfCredits: boolean;
+    hasKnownCredits: boolean;
+    hasKnownRunAllowance: boolean;
+    hasRemainingRuns: boolean;
+}
+/**
+ * The credits arithmetic both the launcher and the picker ask.
+ *
+ * @param burningRate Credits per second of the chosen environment
+ */
+export declare function useNewCodeSandboxAllowance(burningRate: number | undefined): INewCodeSandboxAllowance;
+/** The credits a time reservation stands for. */
+export declare function creditsLimitFor(timeLimitMinutes: number, burningRate: number): number;
+export interface INewCodeSandboxControlsProps {
+    /** Whether the time reservation is offered; it is by default. */
+    withReservation?: boolean;
+    /** Credits per second of the chosen environment. */
+    burningRate?: number;
+    timeLimit: number;
+    onTimeChange: (minutes: number) => void;
+    /** The ceiling of the reservation control. */
+    max: number;
+    disabled?: boolean;
+    error?: string;
+    /** Offered next to the error when credits can be added from here. */
+    addCredits?: () => void;
+    userStorage: boolean;
+    onUserStorageToggle: () => void;
+    storageDisabled?: boolean;
+}
+/**
+ * The two questions of a new sandbox: the time reservation, and the storage.
+ * The storage is withheld on white-label deployments, as it always was.
+ */
+export declare function NewCodeSandboxControls(props: INewCodeSandboxControlsProps): JSX.Element;

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

@@ -0,0 +1,76 @@
+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.
+ */
+/**
+ * What launching a NEW code sandbox asks of the user, in one place.
+ *
+ * The launcher dialog and the picker both offer to start a sandbox, and both
+ * used to carry their own copy of the same questions — how long to reserve,
+ * whether to mount the user storage — and of the same arithmetic over the
+ * credits of the account. This module is the single copy: the hook computes
+ * what the account allows, the component renders the two controls, and the
+ * helper turns a time limit into the credits reservation.
+ *
+ * @module components/code-sandboxes/NewCodeSandboxControls
+ */
+import { FormControl, ToggleSwitch, Tooltip, IconButton } from '@primer/react';
+import { AlertIcon } from '@primer/octicons-react';
+import { useCoreStore, useIAMStore } from '../../state/substates';
+import { CodeSandboxReservationControl, MAXIMAL_CODE_SANDBOX_TIME_RESERVATION_MINUTES, } from './CodeSandboxReservationControl';
+/**
+ * The credits arithmetic both the launcher and the picker ask.
+ *
+ * @param burningRate Credits per second of the chosen environment
+ */
+export function useNewCodeSandboxAllowance(burningRate) {
+    const { credits, user } = useIAMStore();
+    const includedRuns = user?.subscription?.usage?.included_runs ??
+        user?.subscription?.included_runs;
+    const currentRuns = user?.subscription?.usage?.current_runs ??
+        user?.subscription?.current_runs ??
+        user?.subscription?.used_runs;
+    const hasKnownRunAllowance = typeof includedRuns === 'number';
+    const hasRemainingRuns = hasKnownRunAllowance &&
+        typeof currentRuns === 'number' &&
+        includedRuns > 0 &&
+        currentRuns < includedRuns;
+    const hasKnownCredits = typeof credits?.available === 'number';
+    const maxFromCredits = burningRate
+        ? Math.floor((credits?.available ?? 0) / burningRate / 60.0)
+        : undefined;
+    const effectiveMaxMinutes = hasKnownCredits && hasKnownRunAllowance && !hasRemainingRuns
+        ? Math.max(1, maxFromCredits ?? 0)
+        : Math.max(10, maxFromCredits && maxFromCredits > 0 ? maxFromCredits : 0);
+    const outOfCredits = hasKnownCredits &&
+        hasKnownRunAllowance &&
+        !hasRemainingRuns &&
+        ((credits?.available ?? 0) <= 0 || (maxFromCredits ?? 0) < Number.EPSILON);
+    return {
+        maxFromCredits,
+        effectiveMaxMinutes,
+        outOfCredits,
+        hasKnownCredits,
+        hasKnownRunAllowance,
+        hasRemainingRuns,
+    };
+}
+/** The credits a time reservation stands for. */
+export function creditsLimitFor(timeLimitMinutes, burningRate) {
+    return (Math.min(timeLimitMinutes, MAXIMAL_CODE_SANDBOX_TIME_RESERVATION_MINUTES) *
+        burningRate *
+        60);
+}
+/**
+ * The two questions of a new sandbox: the time reservation, and the storage.
+ * The storage is withheld on white-label deployments, as it always was.
+ */
+export function NewCodeSandboxControls(props) {
+    const { addCredits, burningRate, withReservation = true, disabled, error, max, onTimeChange, onUserStorageToggle, storageDisabled, timeLimit, userStorage, } = props;
+    const { configuration } = useCoreStore();
+    return (_jsxs(_Fragment, { children: [withReservation && (_jsx(CodeSandboxReservationControl, { addCredits: addCredits, disabled: disabled, label: 'Time reservation', max: max, time: timeLimit, burningRate: burningRate, onTimeChange: onTimeChange, error: error })), !configuration.whiteLabel && (_jsxs(FormControl, { disabled: storageDisabled, layout: "horizontal", children: [_jsxs(FormControl.Label, { id: "new-sandbox-user-storage-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: storageDisabled, checked: userStorage, size: "small", onClick: event => {
+                            event.preventDefault();
+                            onUserStorageToggle();
+                        }, "aria-labelledby": "new-sandbox-user-storage-label" })] }))] }));
+}

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

@@ -0,0 +1,21 @@
+/**
+ * The code sandboxes: what runs the code of a notebook, a document or a cell.
+ *
+ * One launcher and one picker, and everything they are made of. The launcher
+ * asks for a NEW sandbox and starts it; the picker lists what already runs
+ * next to the environments a new one could be started in. The pickers of a
+ * notebook, of a cell and of a toolbar are compositions of those two — none
+ * of them carries a second copy of either.
+ *
+ * @module components/code-sandboxes
+ */
+export * from './CodeSandboxCellVariables';
+export * from './CodeSandboxCellVariablesDialog';
+export * from './CodeSandboxLauncher';
+export * from './CodeSandboxPicker';
+export * from './CodeSandboxPickerCell';
+export * from './CodeSandboxReservationControl';
+export * from './CodeSandboxTransfer';
+export * from './CodeSandboxUtils';
+export * from './CodeSandboxVariables';
+export * from './NewCodeSandboxControls';

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

@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * The code sandboxes: what runs the code of a notebook, a document or a cell.
+ *
+ * One launcher and one picker, and everything they are made of. The launcher
+ * asks for a NEW sandbox and starts it; the picker lists what already runs
+ * next to the environments a new one could be started in. The pickers of a
+ * notebook, of a cell and of a toolbar are compositions of those two — none
+ * of them carries a second copy of either.
+ *
+ * @module components/code-sandboxes
+ */
+export * from './CodeSandboxCellVariables';
+export * from './CodeSandboxCellVariablesDialog';
+export * from './CodeSandboxLauncher';
+export * from './CodeSandboxPicker';
+export * from './CodeSandboxPickerCell';
+export * from './CodeSandboxReservationControl';
+export * from './CodeSandboxTransfer';
+export * from './CodeSandboxUtils';
+export * from './CodeSandboxVariables';
+export * from './NewCodeSandboxControls';

package/lib/components/index.d.ts

@@ -1,8 +1,6 @@
-export * from './ToolApprovalCard';
-export * from './NotificationEventCard';
-export * from './OutputCard';
-export * from './AgentSummary';
 export * from './a2ui';
-export * from './runtimes';
-export * from './snapshots';
+export * from './agents';
+export * from './cards';
+export * from './code-sandboxes';
 export * from './scheduler';
+export * from './snapshots';

package/lib/components/index.js

@@ -2,11 +2,9 @@
  * Copyright (c) 2025-2026 Datalayer, Inc.
  * Distributed under the terms of the Modified BSD License.
  */
-export * from './ToolApprovalCard';
-export * from './NotificationEventCard';
-export * from './OutputCard';
-export * from './AgentSummary';
 export * from './a2ui';
-export * from './runtimes';
-export * from './snapshots';
+export * from './agents';
+export * from './cards';
+export * from './code-sandboxes';
 export * from './scheduler';
+export * from './snapshots';

package/lib/components/progress/CreditsIndicator.d.ts

@@ -25,6 +25,13 @@ type ICreditsIndicatorProps = {
      * Duration is the kernel max duration
      */
     onUpdate?: (progress: number, duration: number) => void;
+    /**
+     * Paddings of the indicator, each defaulting to the current ones.
+     */
+    paddingLeft?: number | string;
+    paddingRight?: number | string;
+    paddingTop?: number | string;
+    paddingBottom?: number | string;
 };
 /**
  * Credits indicator component.

package/lib/components/progress/CreditsIndicator.js

@@ -5,13 +5,13 @@ import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
  */
 import { useState, useEffect } from 'react';
 import { Box } from '@datalayer/primer-addons';
-import { useNavigate } from '@datalayer/core/lib/hooks/useNavigate';
 import { ConsumptionBar } from '@datalayer/core/lib/components/progress/ConsumptionBar';
+import { useNavigate } from '@datalayer/core/lib/hooks/useNavigate';
 /**
  * Credits indicator component.
  */
 export function CreditsIndicator(props) {
-    const { serviceManager, kernelId, navigateTo, onClick, onUpdate } = props;
+    const { serviceManager, kernelId, navigateTo, onClick, onUpdate, paddingLeft, paddingRight, paddingTop, paddingBottom, } = props;
     const navigate = useNavigate();
     const [model, setModel] = useState();
     useEffect(() => {
@@ -19,5 +19,5 @@ export function CreditsIndicator(props) {
             setModel(model);
         });
     }, [kernelId, serviceManager]);
-    return model ? (_jsx(Box, { display: "flex", style: { alignItems: 'center' }, children: _jsx(ConsumptionBar, { startedAt: parseFloat(model.started_at), expiredAt: model.expired_at ? parseFloat(model.expired_at) : undefined, burningRate: model.burning_rate, onClick: onClick ?? (navigateTo ? () => navigate(navigateTo) : undefined), onUpdate: onUpdate, style: { cursor: 'pointer' } }) })) : (_jsx(_Fragment, {}));
+    return model ? (_jsx(Box, { display: "flex", style: { alignItems: 'center' }, children: _jsx(ConsumptionBar, { startedAt: parseFloat(model.started_at), expiredAt: model.expired_at ? parseFloat(model.expired_at) : undefined, burningRate: model.burning_rate, onClick: onClick ?? (navigateTo ? () => navigate(navigateTo) : undefined), onUpdate: onUpdate, style: { cursor: 'pointer' }, paddingLeft: paddingLeft, paddingRight: paddingRight, paddingTop: paddingTop, paddingBottom: paddingBottom }) })) : (_jsx(_Fragment, {}));
 }

package/lib/context/CostUsageChart.d.ts

@@ -3,11 +3,11 @@ export interface CostUsageChartProps {
     agentId?: string;
     runtimeId?: string;
     apiKey?: string;
-    datalayerUrl?: string;
+    otelUrl?: string;
     wsUrl?: string;
     liveCumulativeUsd?: number;
     liveTimestampMs?: number | null;
     height?: number;
 }
-export declare function CostUsageChart({ serviceName, agentId, runtimeId, apiKey, datalayerUrl, wsUrl, liveCumulativeUsd, liveTimestampMs, height, }: CostUsageChartProps): import("react/jsx-runtime").JSX.Element;
+export declare function CostUsageChart({ serviceName, agentId, runtimeId, apiKey, otelUrl, wsUrl, liveCumulativeUsd, liveTimestampMs, height, }: CostUsageChartProps): import("react/jsx-runtime").JSX.Element;
 export default CostUsageChart;

package/lib/context/CostUsageChart.js

@@ -278,7 +278,7 @@ function maxDefined(rows, selector) {
         return max === undefined ? value : Math.max(max, value);
     }, undefined);
 }
-export function CostUsageChart({ serviceName, agentId, runtimeId, apiKey, datalayerUrl, wsUrl, liveCumulativeUsd, liveTimestampMs, height = 160, }) {
+export function CostUsageChart({ serviceName, agentId, runtimeId, apiKey, otelUrl, wsUrl, liveCumulativeUsd, liveTimestampMs, height = 160, }) {
     const cacheServiceKey = String(serviceName || runtimeId || '').trim() || undefined;
     const monitoringCache = useAgentRuntimeStore(s => s.monitoringCache);
     const mergeCostPoints = useAgentRuntimeStore(s => s.mergeCostPoints);
@@ -327,7 +327,7 @@ export function CostUsageChart({ serviceName, agentId, runtimeId, apiKey, datala
     }, [agentId, cacheServiceKey, cachedEntry]);
     // Bootstrap chart with existing OTEL cost metrics before websocket updates.
     useEffect(() => {
-        if (!cacheServiceKey || !apiKey || !datalayerUrl) {
+        if (!cacheServiceKey || !apiKey || !otelUrl) {
             return;
         }
         let cancelled = false;
@@ -337,14 +337,14 @@ export function CostUsageChart({ serviceName, agentId, runtimeId, apiKey, datala
                     fetchOtelMetricRows({
                         metric: COST_RUN_METRIC,
                         serviceName,
-                        datalayerUrl,
+                        otelUrl,
                         apiKey,
                         limit: 1000,
                     }),
                     fetchOtelMetricRows({
                         metric: COST_CUMULATIVE_METRIC,
                         serviceName,
-                        datalayerUrl,
+                        otelUrl,
                         apiKey,
                         limit: 1000,
                     }),
@@ -391,7 +391,7 @@ export function CostUsageChart({ serviceName, agentId, runtimeId, apiKey, datala
         agentId,
         apiKey,
         cacheServiceKey,
-        datalayerUrl,
+        otelUrl,
         mergeCostPoints,
         runtimeId,
         serviceName,
@@ -439,7 +439,7 @@ export function CostUsageChart({ serviceName, agentId, runtimeId, apiKey, datala
         if (!cacheServiceKey || !apiKey)
             return;
         const rawBaseUrl = wsUrl ||
-            datalayerUrl ||
+            otelUrl ||
             (typeof window !== 'undefined' ? window.location.origin : '');
         if (!rawBaseUrl)
             return;
@@ -496,7 +496,7 @@ export function CostUsageChart({ serviceName, agentId, runtimeId, apiKey, datala
         apiKey,
         cacheServiceKey,
         mergeCostPoints,
-        datalayerUrl,
+        otelUrl,
         runtimeId,
         serviceName,
         wsUrl,