@datalayer/agent-runtimes 1.0.29 → 1.3.10

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

@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/** What a reservation is offered before any credits are known. */
+export const DEFAULT_MINUTES_FLOOR = 10;
+export function codeSandboxAllowance({ available, includedRuns, currentRuns, burningRate, }) {
+    const hasKnownRunAllowance = typeof includedRuns === 'number';
+    const hasRemainingRuns = hasKnownRunAllowance &&
+        typeof currentRuns === 'number' &&
+        includedRuns > 0 &&
+        currentRuns < includedRuns;
+    /*
+     * Finite, not merely a number: `NaN` is a `number`, and reading it as a
+     * known balance is how an account holding thousands of credits was offered
+     * the ten-minute floor. Unknown is unknown, and says so.
+     */
+    const hasKnownCredits = Number.isFinite(available);
+    const maxFromCredits = burningRate && burningRate > 0 && hasKnownCredits
+        ? Math.floor((available ?? 0) / burningRate / 60.0)
+        : undefined;
+    const effectiveMaxMinutes = hasKnownCredits && hasKnownRunAllowance && !hasRemainingRuns
+        ? Math.max(1, maxFromCredits ?? 0)
+        : Math.max(DEFAULT_MINUTES_FLOOR, maxFromCredits && maxFromCredits > 0 ? maxFromCredits : 0);
+    const outOfCredits = hasKnownCredits &&
+        hasKnownRunAllowance &&
+        !hasRemainingRuns &&
+        ((available ?? 0) <= 0 || (maxFromCredits ?? 0) < Number.EPSILON);
+    return {
+        maxFromCredits,
+        effectiveMaxMinutes,
+        outOfCredits,
+        hasKnownCredits,
+        hasKnownRunAllowance,
+        hasRemainingRuns,
+    };
+}

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

@@ -0,0 +1,86 @@
+/**
+ * What the environment dropdown says about an environment, as rules.
+ *
+ * The listing now holds two kinds of thing: the platform's environments, which
+ * have always been there, and the environments people build (PLAN_ENV.md,
+ * E1-01). They are told apart, grouped, priced and — where a variant was never
+ * built — refused here rather than in the components, so the launcher and the
+ * picker cannot come to different conclusions about the same entry, and so the
+ * rules can be read and tested without a DOM.
+ *
+ * Nothing in this module writes a rate: the burning rate of a user environment
+ * is the rate of the size class its promoted version names, and the listing
+ * carries it (D-4, E1-19).
+ *
+ * @module components/code-sandboxes/codeSandboxEnvironments
+ */
+import type { IDatalayerEnvironment } from '../../models';
+import type { ICodeSandboxEnvironmentOption } from './CodeSandboxEnvironmentSelect';
+/**
+ * The variant a sandbox of THIS platform starts on.
+ *
+ * A user environment may be built for Modal, Daytona or E2B as well; those
+ * sandboxes are launched at their provider, not from this dropdown, so what
+ * decides whether an entry can be launched here is the Datalayer artifact.
+ */
+export declare const DATALAYER_LAUNCH_VARIANT = "datalayer";
+/** Where an entry is listed. */
+export type CodeSandboxEnvironmentGroup = 'yours' | 'organizations' | 'library' | 'platform';
+/** The heading each group reads under. */
+export declare const CODE_SANDBOX_ENVIRONMENT_GROUP_TITLES: Record<CodeSandboxEnvironmentGroup, string>;
+/**
+ * The order the groups are offered in: what is yours first, then your
+ * organizations', then the environments you found in the Library, and the
+ * platform's own catalogue last, since it is the always-there fallback.
+ */
+export declare const CODE_SANDBOX_ENVIRONMENT_GROUP_ORDER: CodeSandboxEnvironmentGroup[];
+/** Who is looking: an account uid and a handle, as the IAM store holds them. */
+export type ICodeSandboxEnvironmentViewer = {
+    uid?: string;
+    handle?: string;
+};
+/**
+ * Which group an entry belongs to.
+ *
+ * An entry that reached the picker through the public Library is a *library*
+ * entry, whoever owns it: a published environment is offered where a reader who
+ * came from its public page looks for it (D-12, E2-16). Otherwise a platform
+ * entry says so with its `origin`. A user environment is the caller's own when
+ * the account that owns it is theirs — by uid, or by the handle its name is
+ * written with, `ada/geo`, since that is all an entry carries when the uid is
+ * not at hand. Everything else a caller can see is an environment of one of
+ * their organizations: the listing only ever offers them their own accounts'
+ * (D-19).
+ */
+export declare function codeSandboxEnvironmentGroupOf(environment: Pick<IDatalayerEnvironment, 'name' | 'origin' | 'owner' | 'fromLibrary'>, viewer?: ICodeSandboxEnvironmentViewer): CodeSandboxEnvironmentGroup;
+/** The version a launch of this entry runs, when it is a version anyone pinned. */
+export declare function codeSandboxEnvironmentVersion(environment: Pick<IDatalayerEnvironment, 'origin' | 'promotedVersion'>): number | undefined;
+/** The address of a version's page (E1-21), where its builds are. */
+export declare function environmentVersionHref(uid: string, version?: number): string;
+/**
+ * Whether a sandbox of this entry can be started from here.
+ *
+ * A platform entry always can. A user environment can once a version is
+ * promoted AND that version has a Datalayer artifact: without one the Operator
+ * refuses the launch with `DL_ENV_ARTIFACT_MISSING`, so offering it would be
+ * offering a failure. A listing that does not say which variants are built —
+ * an older Runtimes — is believed rather than doubted: the entry stays
+ * offered, and the refusal, if any, comes from the platform as it did before.
+ */
+export declare function isCodeSandboxEnvironmentLaunchable(environment: Pick<IDatalayerEnvironment, 'origin' | 'promotedVersion' | 'availableVariants' | 'burning_rate'>): boolean;
+/**
+ * Where "Build for this variant" leads: the version's own page, which is where
+ * a build of it is started. Only offered for an entry that has a version to
+ * build, and only when the entry cannot be launched as it stands.
+ */
+export declare function codeSandboxEnvironmentBuildHref(environment: Pick<IDatalayerEnvironment, 'uid' | 'origin' | 'promotedVersion' | 'availableVariants'>): string | undefined;
+/** One entry as the dropdown shows it: what it is, what it costs, and whether it can run. */
+export declare function codeSandboxEnvironmentOption(environment: IDatalayerEnvironment, viewer?: ICodeSandboxEnvironmentViewer, extra?: Partial<ICodeSandboxEnvironmentOption>): ICodeSandboxEnvironmentOption;
+/**
+ * The entries of the dropdown, in the order they read: what is yours, then
+ * your organizations', then the platform's, each in the order the listing gave
+ * them.
+ */
+export declare function codeSandboxEnvironmentOptions(environments: readonly IDatalayerEnvironment[], viewer?: ICodeSandboxEnvironmentViewer, decorate?: (environment: IDatalayerEnvironment) => Partial<ICodeSandboxEnvironmentOption>): ICodeSandboxEnvironmentOption[];
+/** The first entry a launcher may open on: never one that cannot be launched. */
+export declare function firstLaunchableCodeSandboxEnvironment(environments: readonly IDatalayerEnvironment[]): IDatalayerEnvironment | undefined;

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

@@ -0,0 +1,147 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * The variant a sandbox of THIS platform starts on.
+ *
+ * A user environment may be built for Modal, Daytona or E2B as well; those
+ * sandboxes are launched at their provider, not from this dropdown, so what
+ * decides whether an entry can be launched here is the Datalayer artifact.
+ */
+export const DATALAYER_LAUNCH_VARIANT = 'datalayer';
+/** The heading each group reads under. */
+export const CODE_SANDBOX_ENVIRONMENT_GROUP_TITLES = {
+    yours: 'Your environments',
+    organizations: "Your organizations' environments",
+    library: 'Library',
+    platform: 'Platform environments',
+};
+/**
+ * The order the groups are offered in: what is yours first, then your
+ * organizations', then the environments you found in the Library, and the
+ * platform's own catalogue last, since it is the always-there fallback.
+ */
+export const CODE_SANDBOX_ENVIRONMENT_GROUP_ORDER = ['yours', 'organizations', 'library', 'platform'];
+/**
+ * Which group an entry belongs to.
+ *
+ * An entry that reached the picker through the public Library is a *library*
+ * entry, whoever owns it: a published environment is offered where a reader who
+ * came from its public page looks for it (D-12, E2-16). Otherwise a platform
+ * entry says so with its `origin`. A user environment is the caller's own when
+ * the account that owns it is theirs — by uid, or by the handle its name is
+ * written with, `ada/geo`, since that is all an entry carries when the uid is
+ * not at hand. Everything else a caller can see is an environment of one of
+ * their organizations: the listing only ever offers them their own accounts'
+ * (D-19).
+ */
+export function codeSandboxEnvironmentGroupOf(environment, viewer) {
+    if (environment.fromLibrary) {
+        return 'library';
+    }
+    if (environment.origin !== 'user') {
+        return 'platform';
+    }
+    const handle = viewer?.handle;
+    const mine = (!!viewer?.uid && environment.owner === viewer.uid) ||
+        (!!handle && environment.name.startsWith(`${handle}/`));
+    return mine ? 'yours' : 'organizations';
+}
+/** The version a launch of this entry runs, when it is a version anyone pinned. */
+export function codeSandboxEnvironmentVersion(environment) {
+    if (environment.origin !== 'user') {
+        return undefined;
+    }
+    return environment.promotedVersion?.version;
+}
+/** The address of a version's page (E1-21), where its builds are. */
+export function environmentVersionHref(uid, version) {
+    return version === undefined
+        ? `/environments/${uid}/versions`
+        : `/environments/${uid}/versions/${version}`;
+}
+/**
+ * Whether a sandbox of this entry can be started from here.
+ *
+ * A platform entry always can. A user environment can once a version is
+ * promoted AND that version has a Datalayer artifact: without one the Operator
+ * refuses the launch with `DL_ENV_ARTIFACT_MISSING`, so offering it would be
+ * offering a failure. A listing that does not say which variants are built —
+ * an older Runtimes — is believed rather than doubted: the entry stays
+ * offered, and the refusal, if any, comes from the platform as it did before.
+ */
+export function isCodeSandboxEnvironmentLaunchable(environment) {
+    if (environment.origin !== 'user') {
+        return true;
+    }
+    if (!environment.promotedVersion) {
+        return false;
+    }
+    const available = environment.availableVariants;
+    if (available === undefined) {
+        return true;
+    }
+    if (!available.includes(DATALAYER_LAUNCH_VARIANT)) {
+        return false;
+    }
+    /*
+     * And it has to be priceable. A launch reserves credits before anything
+     * starts, so an entry whose size class carries no rate cannot be launched
+     * from here at all — offering it would reserve nothing and be refused by the
+     * platform, which reads to the user as the sandbox failing for no reason.
+     */
+    return !!environment.burning_rate;
+}
+/**
+ * Where "Build for this variant" leads: the version's own page, which is where
+ * a build of it is started. Only offered for an entry that has a version to
+ * build, and only when the entry cannot be launched as it stands.
+ */
+export function codeSandboxEnvironmentBuildHref(environment) {
+    if (environment.origin !== 'user' || !environment.uid) {
+        return undefined;
+    }
+    const available = environment.availableVariants;
+    /*
+     * Only where a BUILD is the thing that is missing. An entry that has its
+     * artifact and cannot be launched for another reason — an unpriced size
+     * class — is not made better by building it again, and an older Runtimes,
+     * which says nothing about artifacts, is not second-guessed.
+     */
+    if (available === undefined || available.includes(DATALAYER_LAUNCH_VARIANT)) {
+        return undefined;
+    }
+    return environmentVersionHref(environment.uid, codeSandboxEnvironmentVersion(environment));
+}
+/** One entry as the dropdown shows it: what it is, what it costs, and whether it can run. */
+export function codeSandboxEnvironmentOption(environment, viewer, extra = {}) {
+    const group = codeSandboxEnvironmentGroupOf(environment, viewer);
+    const version = codeSandboxEnvironmentVersion(environment);
+    return {
+        key: environment.name,
+        title: environment.title || environment.name,
+        name: environment.name,
+        group: CODE_SANDBOX_ENVIRONMENT_GROUP_TITLES[group],
+        version: version === undefined ? undefined : `v${version}`,
+        sizeClass: environment.sizeClass || undefined,
+        burningRate: environment.burning_rate,
+        gpu: environment.resources?.['nvidia.com/gpu'],
+        disabled: !isCodeSandboxEnvironmentLaunchable(environment),
+        buildHref: codeSandboxEnvironmentBuildHref(environment),
+        ...extra,
+    };
+}
+/**
+ * The entries of the dropdown, in the order they read: what is yours, then
+ * your organizations', then the platform's, each in the order the listing gave
+ * them.
+ */
+export function codeSandboxEnvironmentOptions(environments, viewer, decorate) {
+    const options = environments.map(environment => codeSandboxEnvironmentOption(environment, viewer, decorate?.(environment) ?? {}));
+    return CODE_SANDBOX_ENVIRONMENT_GROUP_ORDER.flatMap(group => options.filter(option => option.group === CODE_SANDBOX_ENVIRONMENT_GROUP_TITLES[group]));
+}
+/** The first entry a launcher may open on: never one that cannot be launched. */
+export function firstLaunchableCodeSandboxEnvironment(environments) {
+    return environments.find(isCodeSandboxEnvironmentLaunchable);
+}

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

@@ -7,7 +7,8 @@
  *
  * A sandbox is not one kind of thing: it is a runtime of the platform, a
  * kernel of a Jupyter Server, a kernel of the browser — and, on the Python
- * side, a Kaggle session or a Modal container as well. Each of those is a
+ * side, a Kaggle session, a Modal or CoreWeave container, an E2B microVM, a
+ * Daytona sandbox or a Cloudflare edge container as well. Each of those is a
  * PROVIDER, each ships the environments it offers (the platform ships
  * `ai-agents-env`, Kaggle a CPU and a GPU session), and each is usable only
  * where what it needs is at hand.
@@ -23,6 +24,14 @@
  * answer the same question — which providers can be used from here — so the
  * CLI, the web application and JupyterLab offer the same thing.
  *
+ * The clouds of that registry — Kaggle, Modal, Cloudflare, CoreWeave,
+ * Daytona, E2B — are deliberately absent from the list below. Nothing on this
+ * page holds their credentials, and nothing here should: the operator holds
+ * them, decides which of them an account may use, and serves what they offer
+ * as environments of the platform, each tagged with its provider through
+ * `owner`. So they reach this page under `remote`, one provider as far as the
+ * services are concerned, and `CodeSandboxVariant` is what tells them apart.
+ *
  * @module components/code-sandboxes/codeSandboxProviders
  */
 import { loadJupyterConfig } from '@datalayer/jupyter-react';
@@ -49,7 +58,7 @@ export function codeSandboxProviders(multiServiceManager) {
             available: Boolean(multiServiceManager?.remote),
             unavailableReason: multiServiceManager?.remote
                 ? undefined
-                : 'Sign in to Datalayer to launch a sandbox on the platform.'
+                : 'Sign in to Datalayer to launch a sandbox on the platform.',
         },
         {
             name: 'local',
@@ -57,7 +66,7 @@ export function codeSandboxProviders(multiServiceManager) {
             available: insideJupyterLab && Boolean(multiServiceManager?.local),
             unavailableReason: insideJupyterLab
                 ? undefined
-                : 'The kernels of a Jupyter Server are offered inside JupyterLab.'
+                : 'The kernels of a Jupyter Server are offered inside JupyterLab.',
         },
         {
             name: 'browser',
@@ -65,8 +74,8 @@ export function codeSandboxProviders(multiServiceManager) {
             available: Boolean(multiServiceManager?.browser),
             unavailableReason: multiServiceManager?.browser
                 ? undefined
-                : 'No kernel runs in this browser.'
-        }
+                : 'No kernel runs in this browser.',
+        },
     ];
 }
 /**

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

@@ -11,6 +11,7 @@
  */
 export * from './CodeSandboxCellVariables';
 export * from './CodeSandboxCellVariablesDialog';
+export * from './codeSandboxEnvironments';
 export * from './CodeSandboxEnvironmentSelect';
 export * from './CodeSandboxLauncher';
 export * from './CodeSandboxPicker';

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

@@ -15,6 +15,7 @@
  */
 export * from './CodeSandboxCellVariables';
 export * from './CodeSandboxCellVariablesDialog';
+export * from './codeSandboxEnvironments';
 export * from './CodeSandboxEnvironmentSelect';
 export * from './CodeSandboxLauncher';
 export * from './CodeSandboxPicker';

package/lib/components/context/SpaceSelect.d.ts

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

package/lib/components/flashes/FlashDisclaimer.d.ts

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

package/lib/components/icons/ArtifactIcon.d.ts

@@ -1,3 +1,4 @@
+import type { JSX } from 'react';
 import { Icon } from '@primer/octicons-react';
 import { IAnyItem, IItemType } from '../../models';
 type IArtifactIconClassProp = {

package/lib/components/nbgrader/NbGradesDetails.d.ts

@@ -1,5 +1,5 @@
 import { IStudentItem } from '../../models';
 export declare const NbGradesDetails: (props: {
     studentItem?: IStudentItem;
-}) => import("react/jsx-runtime").JSX.Element;
+}) => import("react").JSX.Element;
 export default NbGradesDetails;

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

@@ -1,3 +1,4 @@
+import type { JSX } from 'react';
 import type { IRemoteServicesManager } from '../../runtimes';
 type ICreditsIndicatorProps = {
     /**

package/lib/components/progress/CreditsIndicator.js

@@ -1,8 +1,4 @@
 import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
-/*
- * Copyright (c) 2025-2026 Datalayer, Inc.
- * Distributed under the terms of the Modified BSD License.
- */
 import { useState, useEffect } from 'react';
 import { Box } from '@datalayer/primer-addons';
 import { ConsumptionBar } from '@datalayer/core/lib/components/progress/ConsumptionBar';

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

@@ -50,5 +50,5 @@ export type ScheduleMenuProps = {
  * anchor icon while a save request is in flight. The scheduler service URL is
  * configurable through the `baseUrl` prop.
  */
-export declare const ScheduleMenu: ({ notebookUid, scheduleUid, token, baseUrl, enabled, icon, iconColor, ariaLabel, initialPreset, initialCronExpression, onSaved, onDeleted, onError, }: ScheduleMenuProps) => import("react/jsx-runtime").JSX.Element;
+export declare const ScheduleMenu: ({ notebookUid, scheduleUid, token, baseUrl, enabled, icon, iconColor, ariaLabel, initialPreset, initialCronExpression, onSaved, onDeleted, onError, }: ScheduleMenuProps) => import("react").JSX.Element;
 export default ScheduleMenu;

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

@@ -1,3 +1,4 @@
+import type { JSX } from 'react';
 import { type PropsWithChildren } from 'react';
 import { Kernel } from '@jupyterlab/services';
 import { IMultiServiceManager } from '../../runtimes';
@@ -20,7 +21,7 @@ type ICodeSandboxSnapshotMenu = {
      *
      * It is needed for remote kernels.
      */
-    podName?: string;
+    runtimeName?: string;
     /**
      * Whether the menu is disabled.
      */
@@ -29,5 +30,5 @@ type ICodeSandboxSnapshotMenu = {
 /**
  * Code Sandbox Snapshot menu component.
  */
-export declare function SandboxSnapshotMenu({ children, connection, podName, multiServiceManager, disabled, }: PropsWithChildren<ICodeSandboxSnapshotMenu>): JSX.Element;
+export declare function SandboxSnapshotMenu({ children, connection, runtimeName, multiServiceManager, disabled, }: PropsWithChildren<ICodeSandboxSnapshotMenu>): JSX.Element;
 export {};

package/lib/components/snapshots/SandboxSnapshotMenu.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, useState, } from 'react';
 import { DeviceCameraIcon } from '@primer/octicons-react';
 import { ActionList, ActionMenu, Flash, FormControl, Select, Spinner, } from '@primer/react';
@@ -15,7 +11,7 @@ import { createSandboxSnapshotName } from '@datalayer/core/lib/utils';
 /**
  * Code Sandbox Snapshot menu component.
  */
-export function SandboxSnapshotMenu({ children, connection, podName, multiServiceManager, disabled = false, }) {
+export function SandboxSnapshotMenu({ children, connection, runtimeName, multiServiceManager, disabled = false, }) {
     const { addSandboxSnapshot, runtimesUrl, runtimeSnapshots, setSandboxSnapshots, } = useRuntimesStore();
     const { enqueueToast, trackAsyncTask } = useToast();
     const [openLoadDialog, setOpenLoadDialog] = useState(false);
@@ -42,10 +38,10 @@ export function SandboxSnapshotMenu({ children, connection, podName, multiServic
     const onSandboxSnapshotChanged = useCallback(event => {
         setSelection(event.target.value);
     }, []);
-    const onLoadSandboxSnapshotSubmit = useCallback(async ({ id, connection, podName, }) => {
-        if (podName) {
-            await loadSandboxSnapshot({ id: podName, from: id });
-            enqueueToast(`Code Sandbox snapshot ${podName} is loaded.`, {
+    const onLoadSandboxSnapshotSubmit = useCallback(async ({ id, connection, runtimeName, }) => {
+        if (runtimeName) {
+            await loadSandboxSnapshot({ id: runtimeName, from: id });
+            enqueueToast(`Code Sandbox snapshot ${runtimeName} is loaded.`, {
                 variant: 'success',
             });
         }
@@ -63,15 +59,15 @@ export function SandboxSnapshotMenu({ children, connection, podName, multiServic
             let task;
             let ref = '';
             let snapshotName = '';
-            if (podName && multiServiceManager?.remote) {
+            if (runtimeName && multiServiceManager?.remote) {
                 snapshotName = createSandboxSnapshotName('cloud');
                 task = multiServiceManager.remote.runtimesManager.snapshotRuntime({
-                    podName,
+                    runtimeName,
                     name: snapshotName,
                     description: snapshotName,
                     stop: false,
                 });
-                ref = podName.split('-', 2).reverse()[0];
+                ref = runtimeName.split('-', 2).reverse()[0];
                 task.then(s => {
                     snapshot = s;
                 });
@@ -121,7 +117,7 @@ export function SandboxSnapshotMenu({ children, connection, podName, multiServic
         finally {
             setTakingSandboxSnapshot(false);
         }
-    }, [connection, podName, multiServiceManager]);
+    }, [connection, runtimeName, multiServiceManager]);
     return (_jsxs(_Fragment, { children: [_jsxs(ActionMenu, { children: [_jsx(ActionMenu.Button, { leadingVisual: DeviceCameraIcon, variant: "invisible", size: "small", disabled: loadingSandboxSnapshot || takingSandboxSnapshot || disabled, children: children }), _jsx(ActionMenu.Overlay, { children: _jsxs(ActionList, { children: [_jsx(ActionList.Item, { onSelect: onLoadSandboxSnapshot, disabled: loadingSandboxSnapshot || runtimeSnapshots.length === 0, children: "Load a code sandbox snapshot\u2026" }), _jsx(ActionList.Item, { onSelect: onTakeSandboxSnapshot, disabled: takingSandboxSnapshot, children: "Take a code sandbox snapshot" })] }) })] }), openLoadDialog && (_jsx(Dialog, { title: _jsx("span", { style: { color: 'var(--fgColor-default)' }, children: "Choose a code sandbox snapshot to load" }), onClose: () => {
                     setOpenLoadDialog(false);
                 }, footerButtons: [
@@ -146,11 +142,11 @@ export function SandboxSnapshotMenu({ children, connection, podName, multiServic
                                 try {
                                     setError(undefined);
                                     const snapshot = runtimeSnapshots.find(s => s.id === selection);
-                                    if (snapshot && (connection || podName)) {
+                                    if (snapshot && (connection || runtimeName)) {
                                         await onLoadSandboxSnapshotSubmit({
                                             connection,
                                             id: snapshot.id,
-                                            podName,
+                                            runtimeName,
                                         });
                                     }
                                     else {

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

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

package/lib/components/snippets/SnippetDialog.js

@@ -1,8 +1,4 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-/*
- * Copyright (c) 2025-2026 Datalayer, Inc.
- * Distributed under the terms of the Modified BSD License.
- */
 import { useCallback, useMemo, useState } from 'react';
 import { nullTranslator } from '@jupyterlab/translation';
 import { FormControl, Select, Text } from '@primer/react';

package/lib/components/specs/SpecPayloadPreview.d.ts

@@ -0,0 +1,34 @@
+/**
+ * A spec, as the YAML somebody would have written.
+ *
+ * The agentspecs example grew this to show what it was about to launch, and
+ * the agent details pane wants the same thing for what is already running —
+ * "here is the spec, in the form it is written in" is one question, and two
+ * renderings of it would drift.
+ *
+ * The serialiser is deliberately small and local. A YAML library would be a
+ * dependency for a read-only preview of data this application produced itself,
+ * and the shapes here are plain objects, arrays, strings and numbers.
+ *
+ * @module components/specs/SpecPayloadPreview
+ */
+import type { JSX } from 'react';
+/** A spec rendered as YAML. Exported for callers that only want the text. */
+export declare function specToYaml(value: unknown): string;
+export type SpecPayloadPreviewProps = {
+    /** The spec to render. */
+    spec: unknown;
+    /** Called when the reader dismisses it. */
+    onClose: () => void;
+    /** What the panel calls itself. */
+    title?: string;
+};
+/**
+ * The preview, as a panel over whatever is behind it.
+ *
+ * Escape closes it as well as the button, because a panel that covers the
+ * view and can only be dismissed by finding one control is a panel people
+ * feel trapped in.
+ */
+export declare function SpecPayloadPreview({ spec, onClose, title, }: SpecPayloadPreviewProps): JSX.Element;
+export default SpecPayloadPreview;

package/lib/components/specs/SpecPayloadPreview.js

@@ -0,0 +1,102 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect } from 'react';
+import { IconButton, Text } from '@primer/react';
+import { XIcon } from '@primer/octicons-react';
+import { Box } from '@datalayer/primer-addons';
+const isPlainObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const yamlScalar = (value) => {
+    if (value === null || value === undefined) {
+        return 'null';
+    }
+    if (typeof value === 'number' || typeof value === 'boolean') {
+        return String(value);
+    }
+    const str = String(value);
+    if (str === '') {
+        return "''";
+    }
+    if (/^[a-zA-Z0-9._/-]+$/.test(str)) {
+        return str;
+    }
+    return JSON.stringify(str);
+};
+const toYaml = (value, indent = 0) => {
+    const pad = '  '.repeat(indent);
+    if (Array.isArray(value)) {
+        if (value.length === 0) {
+            return '[]';
+        }
+        return value
+            .map(item => {
+            if (isPlainObject(item) || Array.isArray(item)) {
+                return `${pad}-\n${toYaml(item, indent + 1)}`;
+            }
+            return `${pad}- ${yamlScalar(item)}`;
+        })
+            .join('\n');
+    }
+    if (isPlainObject(value)) {
+        const entries = Object.entries(value).filter(([, v]) => v !== undefined);
+        if (entries.length === 0) {
+            return '{}';
+        }
+        return entries
+            .map(([key, val]) => {
+            if (isPlainObject(val) || Array.isArray(val)) {
+                return `${pad}${key}:\n${toYaml(val, indent + 1)}`;
+            }
+            return `${pad}${key}: ${yamlScalar(val)}`;
+        })
+            .join('\n');
+    }
+    return `${pad}${yamlScalar(value)}`;
+};
+/** A spec rendered as YAML. Exported for callers that only want the text. */
+export function specToYaml(value) {
+    return toYaml(value);
+}
+/**
+ * The preview, as a panel over whatever is behind it.
+ *
+ * Escape closes it as well as the button, because a panel that covers the
+ * view and can only be dismissed by finding one control is a panel people
+ * feel trapped in.
+ */
+export function SpecPayloadPreview({ spec, onClose, title = 'Spec Payload Preview (YAML)', }) {
+    useEffect(() => {
+        const onKeyDown = (event) => {
+            if (event.key === 'Escape') {
+                onClose();
+            }
+        };
+        document.addEventListener('keydown', onKeyDown);
+        return () => document.removeEventListener('keydown', onKeyDown);
+    }, [onClose]);
+    return (_jsxs(Box, { role: "dialog", "aria-label": title, "aria-modal": "true", sx: {
+            position: 'fixed',
+            inset: 24,
+            zIndex: 300,
+            bg: 'canvas.default',
+            border: '1px solid',
+            borderColor: 'border.default',
+            borderRadius: 1,
+            boxShadow: 'shadow.large',
+            display: 'flex',
+            flexDirection: 'column',
+        }, children: [_jsxs(Box, { sx: {
+                    display: 'flex',
+                    alignItems: 'center',
+                    justifyContent: 'space-between',
+                    px: 3,
+                    py: 2,
+                    borderBottom: '1px solid',
+                    borderColor: 'border.default',
+                }, children: [_jsx(Text, { sx: { fontWeight: 'bold' }, children: title }), _jsx(IconButton, { icon: XIcon, "aria-label": "Close spec preview", size: "small", variant: "invisible", onClick: onClose })] }), _jsx(Box, { sx: { p: 3, overflow: 'auto', flex: 1 }, children: _jsx(Box, { as: "pre", sx: {
+                        m: 0,
+                        whiteSpace: 'pre',
+                        fontFamily: 'monospace',
+                        fontSize: 0,
+                        lineHeight: '20px',
+                    }, children: specToYaml(spec) }) })] }));
+}
+export default SpecPayloadPreview;

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

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