@datalayer/core 0.0.12 → 0.0.14

package/lib/client/mixins/SpacerMixin.js

@@ -0,0 +1,340 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * Spacer mixin for managing workspaces, notebooks, and content.
+ * @module client/mixins/SpacerMixin
+ */
+import * as spaces from '../../api/spacer/spaces';
+import * as notebooks from '../../api/spacer/notebooks';
+import * as users from '../../api/spacer/users';
+import * as lexicals from '../../api/spacer/lexicals';
+import * as documents from '../../api/spacer/documents';
+import * as items from '../../api/spacer/items';
+import { NotebookDTO } from '../../models/NotebookDTO';
+import { LexicalDTO } from '../../models/LexicalDTO';
+import { SpaceDTO } from '../../models/SpaceDTO';
+import { HealthCheck } from '../../models/HealthCheck';
+import { convertSpaceItemsToModels } from '../utils/spacerUtils';
+/** Spacer mixin providing workspace and content management. */
+export function SpacerMixin(Base) {
+    return class extends Base {
+        // ========================================================================
+        // User
+        // ========================================================================
+        /**
+         * Get all workspaces for the authenticated user.
+         * @returns Array of Space instances
+         */
+        async getMySpaces() {
+            const token = this.getToken();
+            const spacerRunUrl = this.getSpacerRunUrl();
+            const response = await users.getMySpaces(token, spacerRunUrl);
+            return response.spaces.map(s => new SpaceDTO(s, this));
+        }
+        // ========================================================================
+        // Spaces
+        // ========================================================================
+        /**
+         * Create a new workspace.
+         * @param name - Space name
+         * @param description - Space description
+         * @param variant - Space variant type
+         * @param spaceHandle - Unique handle for the space
+         * @param organizationId - Organization ID
+         * @param seedSpaceId - Seed space ID for initialization
+         * @param isPublic - Whether the space is public
+         * @returns Created Space instance
+         */
+        async createSpace(name, description, variant, spaceHandle, organizationId, seedSpaceId, isPublic) {
+            const token = this.getToken();
+            const spacerRunUrl = this.getSpacerRunUrl();
+            const data = {
+                name,
+                description,
+                variant,
+                spaceHandle,
+                organizationId,
+                seedSpaceId,
+                public: isPublic,
+            };
+            const response = await spaces.createSpace(token, data, spacerRunUrl);
+            if (!response.space) {
+                throw new Error('Failed to create space: no space returned');
+            }
+            return new SpaceDTO(response.space, this);
+        }
+        // ========================================================================
+        // Notebooks
+        // ========================================================================
+        /**
+         * Create a new notebook.
+         * @param spaceId - ID of the space to create the notebook in
+         * @param name - Name of the notebook
+         * @param description - Description of the notebook
+         * @param file - Optional file for notebook content
+         * @returns Created Notebook instance
+         */
+        async createNotebook(spaceId, name, description, file) {
+            // Get the Space model instance
+            const spaces = await this.getMySpaces();
+            const spaceModel = spaces.find((s) => s.uid === spaceId);
+            if (!spaceModel) {
+                throw new Error(`Space with ID '${spaceId}' not found`);
+            }
+            // Use the Space model's createNotebook method
+            return await spaceModel.createNotebook({
+                name,
+                description,
+                file,
+            });
+        }
+        /**
+         * Get a notebook by ID.
+         * @param id - Notebook ID
+         * @returns Notebook instance
+         */
+        async getNotebook(id) {
+            const spacerRunUrl = this.getSpacerRunUrl();
+            const token = this.getToken();
+            const response = await notebooks.getNotebook(token, id, spacerRunUrl);
+            if (!response.notebook) {
+                throw new Error(`Notebook with ID '${id}' not found`);
+            }
+            return new NotebookDTO(response.notebook, this);
+        }
+        /**
+         * Update a notebook.
+         * @param id - Notebook ID
+         * @param name - Optional new name for the notebook
+         * @param description - Optional new description for the notebook
+         * @returns Updated Notebook instance
+         */
+        async updateNotebook(id, name, description) {
+            const spacerRunUrl = this.getSpacerRunUrl();
+            const token = this.getToken();
+            const data = {};
+            if (name !== undefined)
+                data.name = name;
+            if (description !== undefined)
+                data.description = description;
+            const response = await notebooks.updateNotebook(token, id, data, spacerRunUrl);
+            if (!response.notebook) {
+                throw new Error('Failed to update notebook: no notebook returned');
+            }
+            return new NotebookDTO(response.notebook, this);
+        }
+        // ========================================================================
+        // Lexicals
+        // ========================================================================
+        /**
+         * Create a new lexical document.
+         * @param spaceId - ID of the space to create the lexical document in
+         * @param name - Name of the lexical document
+         * @param description - Description of the lexical document
+         * @param file - Optional file for document content
+         * @returns Created Lexical instance
+         */
+        async createLexical(spaceId, name, description, file) {
+            // Get the Space model instance
+            const spaces = await this.getMySpaces();
+            const spaceModel = spaces.find((s) => s.uid === spaceId);
+            if (!spaceModel) {
+                throw new Error(`Space with ID '${spaceId}' not found`);
+            }
+            // Use the Space model's createLexical method
+            return await spaceModel.createLexical({
+                name,
+                description,
+                file,
+            });
+        }
+        /**
+         * Get a lexical document by ID.
+         * @param id - Document ID
+         * @returns Lexical instance
+         */
+        async getLexical(id) {
+            const spacerRunUrl = this.getSpacerRunUrl();
+            const token = this.getToken();
+            const response = await lexicals.getLexical(token, id, spacerRunUrl);
+            if (!response.document) {
+                throw new Error(`Lexical document with ID '${id}' not found`);
+            }
+            return new LexicalDTO(response.document, this);
+        }
+        /**
+         * Update a lexical document.
+         * @param id - Document ID
+         * @param name - Optional new name for the lexical document
+         * @param description - Optional new description for the lexical document
+         * @returns Updated Lexical instance
+         */
+        async updateLexical(id, name, description) {
+            const spacerRunUrl = this.getSpacerRunUrl();
+            const token = this.getToken();
+            const data = {};
+            if (name !== undefined)
+                data.name = name;
+            if (description !== undefined)
+                data.description = description;
+            const response = await lexicals.updateLexical(token, id, data, spacerRunUrl);
+            return new LexicalDTO(response.document, this);
+        }
+        // ========================================================================
+        // Items
+        // ========================================================================
+        /**
+         * Get the items of a space as model instances.
+         * @param spaceId - Space ID
+         * @returns Array of Notebook and Lexical model instances
+         */
+        async getSpaceItems(spaceId) {
+            const spacerRunUrl = this.getSpacerRunUrl();
+            const token = this.getToken();
+            const response = await items.getSpaceItems(token, spaceId, spacerRunUrl);
+            // Use shared utility function to convert items to model instances
+            return convertSpaceItemsToModels(response.items, this);
+        }
+        /**
+         * Get a single item from a space.
+         * @param itemId - Item ID to retrieve
+         * @returns Notebook or Lexical model instance
+         * @throws Error if item not found
+         */
+        async getSpaceItem(itemId) {
+            const spacerRunUrl = this.getSpacerRunUrl();
+            const token = this.getToken();
+            const response = await items.getItem(token, itemId, spacerRunUrl);
+            if (!response.success || !response.item) {
+                throw new Error(`Space item '${itemId}' not found`);
+            }
+            // Determine item type and create appropriate model
+            const item = response.item;
+            if (item.type_s === 'notebook' || item.notebook_name_s !== undefined) {
+                return new NotebookDTO(item, this);
+            }
+            else if (item.type_s === 'lexical' ||
+                item.document_name_s !== undefined) {
+                return new LexicalDTO(item, this);
+            }
+            else {
+                throw new Error(`Unknown item type for item '${itemId}'`);
+            }
+        }
+        /**
+         * Delete an item from a space.
+         * @param itemId - Item ID to delete
+         * @throws Error if deletion fails
+         */
+        async deleteSpaceItem(itemId) {
+            const spacerRunUrl = this.getSpacerRunUrl();
+            const token = this.getToken();
+            // First, check if the item exists
+            try {
+                const getResponse = await items.getItem(token, itemId, spacerRunUrl);
+                if (!getResponse.success || !getResponse.item) {
+                    throw new Error(`Space item '${itemId}' not found`);
+                }
+            }
+            catch (error) {
+                // If getItem throws (e.g., 404), wrap in descriptive error
+                if (error.message?.includes('404') ||
+                    error.message?.includes('not found')) {
+                    throw new Error(`Failed to delete space item '${itemId}': Item not found`);
+                }
+                throw new Error(`Failed to delete space item '${itemId}': ${error.message}`);
+            }
+            // Item exists, proceed with deletion
+            const response = await items.deleteItem(token, itemId, spacerRunUrl);
+            if (!response.success) {
+                throw new Error(`Failed to delete space item '${itemId}': ${response.message}`);
+            }
+            // Success - return void
+        }
+        // ========================================================================
+        // Content Loading with CDN Support
+        // ========================================================================
+        async getContent(itemId) {
+            const spacerRunUrl = this.getSpacerRunUrl();
+            const token = this.getToken();
+            // First, get the item to check for CDN URL
+            const response = await items.getItem(token, itemId, spacerRunUrl);
+            if (!response.success || !response.item) {
+                throw new Error(`Space item '${itemId}' not found`);
+            }
+            const item = response.item;
+            const cdnUrl = item.cdn_url_s;
+            if (cdnUrl) {
+                // Load content from CDN
+                const cdnResponse = await fetch(cdnUrl);
+                if (!cdnResponse.ok) {
+                    throw new Error(`Failed to load content from CDN: ${cdnResponse.statusText}`);
+                }
+                return await cdnResponse.json();
+            }
+            // No CDN URL, return content from item
+            return item.content;
+        }
+        // ========================================================================
+        // Service Health Checks
+        // ========================================================================
+        /**
+         * Check the health status of the Spacer service.
+         * Performs a lightweight check to verify service accessibility.
+         *
+         * @returns Health check result with status and response time
+         */
+        async checkSpacerHealth() {
+            const startTime = Date.now();
+            const errors = [];
+            let status = 'unknown';
+            let healthy = false;
+            try {
+                // Test basic connectivity by getting user spaces (lightweight operation)
+                const spaces = await this.getMySpaces();
+                const responseTime = Date.now() - startTime;
+                if (Array.isArray(spaces)) {
+                    healthy = true;
+                    status = 'operational';
+                }
+                else {
+                    status = 'degraded';
+                    errors.push('Unexpected response format from spaces endpoint');
+                }
+                return new HealthCheck({
+                    healthy,
+                    status,
+                    responseTime,
+                    errors,
+                    timestamp: new Date(),
+                }, this);
+            }
+            catch (error) {
+                const responseTime = Date.now() - startTime;
+                status = 'down';
+                errors.push(`Service unreachable: ${error}`);
+                return new HealthCheck({
+                    healthy: false,
+                    status,
+                    responseTime,
+                    errors,
+                    timestamp: new Date(),
+                }, this);
+            }
+        }
+        /**
+         * Get collaboration session ID for a document
+         */
+        async getCollaborationSessionId(documentId) {
+            const token = this.getToken();
+            const spacerRunUrl = this.getSpacerRunUrl();
+            const response = await documents.getCollaborationSessionId(token, documentId, spacerRunUrl);
+            if (!response.success || !response.sessionId) {
+                throw new Error(`Failed to get collaboration session ID for document '${documentId}': ${response.error || 'Unknown error'}`);
+            }
+            return response.sessionId;
+        }
+    };
+}

package/lib/client/utils/mixins.d.ts

@@ -0,0 +1,12 @@
+/**
+ * TypeScript mixin utilities for composing the DatalayerClient class.
+ * @module client/utils/mixins
+ */
+/** Type for a constructor function that can be used in mixins. */
+export type Constructor<T = {}> = new (...args: any[]) => T;
+/**
+ * Apply mixins to a base class.
+ * @param derivedCtor - The base class to extend
+ * @param constructors - Array of mixin classes to apply
+ */
+export declare function applyMixins(derivedCtor: any, constructors: any[]): void;

package/lib/{sdk/client → client}/utils/mixins.js

@@ -4,36 +4,8 @@
  */
 /**
  * Apply mixins to a base class.
- *
- * This utility function enables multiple inheritance-like behavior in TypeScript
- * by copying properties and methods from mixin classes to the target class.
- *
  * @param derivedCtor - The base class to extend
  * @param constructors - Array of mixin classes to apply
- *
- * @example
- * ```typescript
- * class Base {
- *   baseMethod() { return 'base'; }
- * }
- *
- * class MixinA {
- *   mixinAMethod() { return 'A'; }
- * }
- *
- * class MixinB {
- *   mixinBMethod() { return 'B'; }
- * }
- *
- * interface Combined extends Base, MixinA, MixinB {}
- * class Combined extends Base {}
- * applyMixins(Combined, [MixinA, MixinB]);
- *
- * const instance = new Combined();
- * instance.baseMethod(); // 'base'
- * instance.mixinAMethod(); // 'A'
- * instance.mixinBMethod(); // 'B'
- * ```
  */
 export function applyMixins(derivedCtor, constructors) {
     constructors.forEach(baseCtor => {

package/lib/client/utils/spacerUtils.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Utility functions for Spacer-related operations to avoid code duplication.
+ * @module client/utils/spacerUtils
+ */
+import type { GetSpaceItemsResponse } from '../../models/SpaceDTO';
+import type { DatalayerClient } from '../index';
+import { NotebookDTO } from '../../models/NotebookDTO';
+import { LexicalDTO } from '../../models/LexicalDTO';
+/**
+ * Convert raw space items from API response to model instances.
+ * This utility function is shared between Space.getItems() and SpacerMixin.getSpaceItems()
+ * to avoid code duplication.
+ *
+ * @param response - Raw API response containing space items
+ * @param sdk - SDK instance to pass to model constructors
+ * @returns Array of Notebook and Lexical model instances
+ */
+export declare function convertSpaceItemsToModels(items: GetSpaceItemsResponse['items'], sdk: DatalayerClient): (NotebookDTO | LexicalDTO)[];

package/lib/client/utils/spacerUtils.js

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { NotebookDTO } from '../../models/NotebookDTO';
+import { LexicalDTO } from '../../models/LexicalDTO';
+import { ItemTypes } from '../constants';
+/**
+ * Convert raw space items from API response to model instances.
+ * This utility function is shared between Space.getItems() and SpacerMixin.getSpaceItems()
+ * to avoid code duplication.
+ *
+ * @param response - Raw API response containing space items
+ * @param sdk - SDK instance to pass to model constructors
+ * @returns Array of Notebook and Lexical model instances
+ */
+export function convertSpaceItemsToModels(items, sdk) {
+    const modelItems = [];
+    for (const item of items) {
+        // Check various possible type fields
+        const itemType = item.type_s;
+        // Only include notebooks and lexicals
+        if (itemType === ItemTypes.NOTEBOOK) {
+            modelItems.push(new NotebookDTO(item, sdk));
+        }
+        else if (itemType === ItemTypes.LEXICAL) {
+            modelItems.push(new LexicalDTO(item, sdk));
+        }
+        // Skip everything else (exercises, cells, etc.)
+    }
+    return modelItems;
+}

package/lib/collaboration/DatalayerCollaboration.d.ts

@@ -1,9 +1,14 @@
 type IFetchSessionId = {
     url: string;
     token?: string;
+    /**
+     * Custom fetch function to use instead of global fetch.
+     * Useful for proxying requests in environments with CORS restrictions (e.g., VS Code webviews).
+     */
+    fetchFn?: typeof fetch;
 };
 /**
  * Fetch the session ID of a collaborative documents from Datalayer.
  */
-export declare function requestDatalayerCollaborationSessionId({ url, token, }: IFetchSessionId): Promise<string>;
+export declare function requestDatalayerCollaborationSessionId({ url, token, fetchFn, }: IFetchSessionId): Promise<string>;
 export {};

package/lib/collaboration/DatalayerCollaboration.js

@@ -5,14 +5,14 @@
 /**
  * Fetch the session ID of a collaborative documents from Datalayer.
  */
-export async function requestDatalayerCollaborationSessionId({ url, token, }) {
+export async function requestDatalayerCollaborationSessionId({ url, token, fetchFn = fetch, }) {
     const headers = {
         Accept: 'application/json',
     };
     if (token) {
         headers['Authorization'] = `Bearer ${token}`;
     }
-    const response = await fetch(url, {
+    const response = await fetchFn(url, {
         method: 'GET',
         headers,
         credentials: token ? 'include' : 'omit',

package/lib/collaboration/DatalayerCollaborationProvider.d.ts

@@ -19,6 +19,11 @@ export interface IDatalayerCollaborationConfig {
      * Authentication token (optional, uses config from store if not provided)
      */
     token?: string;
+    /**
+     * Custom fetch function to use for HTTP requests.
+     * Useful for proxying requests in environments with CORS restrictions (e.g., VS Code webviews).
+     */
+    fetchFn?: typeof fetch;
 }
 /**
  * Datalayer collaboration provider

package/lib/collaboration/DatalayerCollaborationProvider.js

@@ -14,7 +14,6 @@ var CollaborationStatus;
     CollaborationStatus["Error"] = "error";
 })(CollaborationStatus || (CollaborationStatus = {}));
 import { requestDatalayerCollaborationSessionId } from './DatalayerCollaboration';
-import { coreStore } from '../state/substates/CoreState';
 /**
  * Datalayer collaboration provider
  *
@@ -64,24 +63,26 @@ export class DatalayerCollaborationProvider {
         }
         this.setStatus(CollaborationStatus.Connecting);
         try {
-            // Get configuration from store or use provided config
-            const { configuration } = coreStore.getState();
-            const runUrl = this._config.runUrl ?? configuration?.runUrl;
-            const token = this._config.token ?? configuration?.token;
+            // Use ONLY explicitly provided configuration
+            // NO fallback to coreStore - if config is wrong, we want to fail fast
+            // This is critical for VS Code extension where config must come from settings
+            const runUrl = this._config.runUrl;
+            const token = this._config.token;
             if (!runUrl) {
-                throw new Error('Datalayer runUrl is not configured');
+                throw new Error('Datalayer runUrl is not configured - must be explicitly provided in DatalayerCollaborationProvider config');
             }
             if (!token) {
-                throw new Error('Datalayer token is not configured');
+                throw new Error('Datalayer token is not configured - must be explicitly provided in DatalayerCollaborationProvider config');
             }
             const { ydoc, awareness } = sharedModel;
-            // Build WebSocket URL
+            // Build URLs.
             const documentURL = URLExt.join(runUrl, '/api/spacer/v1/documents');
-            const wsUrl = documentURL.replace(/^http/, 'ws');
+            const wsUrl = URLExt.join(runUrl, '/api/spacer/v1/documents/ws').replace(/^http/, 'ws');
             // Request collaboration session from Datalayer
             const sessionId = await requestDatalayerCollaborationSessionId({
                 url: URLExt.join(documentURL, documentId),
                 token,
+                fetchFn: this._config.fetchFn,
             });
             // Create WebSocket provider
             this._provider = new WebsocketProvider(wsUrl, documentId, ydoc, {

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

@@ -1,4 +1,4 @@
-import type { IRemoteServicesManager } from '../../sdk/stateful/runtimes';
+import type { IRemoteServicesManager } from '../../stateful/runtimes';
 type ICreditsIndicatorProps = {
     /**
      * Kernel service manager

package/lib/components/runtimes/RuntimeCellVariablesDialog.js

@@ -8,7 +8,7 @@ import { Dialog } from '@primer/react/experimental';
 import { nullTranslator } from '@jupyterlab/translation';
 import { JSONExt } from '@lumino/coreutils';
 import { KernelExecutor } from '@datalayer/jupyter-react';
-import { RuntimeSnippetsFacade } from '../../sdk/stateful/jupyter';
+import { RuntimeSnippetsFacade } from '../../stateful/jupyter';
 import { RuntimeCellVariables } from './RuntimeCellVariables';
 /**
  * Dialog to define the runtime cell variables to transfer

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

@@ -1,5 +1,5 @@
 import type { IMarkdownParser, IRenderMime } from '@jupyterlab/rendermime';
-import type { IRemoteServicesManager } from '../../sdk/stateful/runtimes';
+import type { IRemoteServicesManager } from '../../stateful/runtimes';
 import type { IRuntimeSnapshot, IRuntimeDesc } from '../../models';
 /**
  * {@link RuntimeLauncherDialog} properties.

package/lib/components/runtimes/RuntimeLauncherDialog.js

@@ -50,7 +50,7 @@ export function RuntimeLauncherDialog(props) {
     const jupyterLabAdapter = jupyterReactStore.jupyterLabAdapter;
     const [selection, setSelection] = useState((kernelSnapshot?.environment || environments[0]?.name) ?? '');
     const [timeLimit, setTimeLimit] = useState(Math.min(credits?.available ?? 0, 10));
-    const [runtimeName, setRuntimeName] = useState(environments[0]?.kernel?.givenNameTemplate || environments[0]?.title || '');
+    const [runtimeName, setRuntimeName] = useState(environments[0]?.runtime?.givenNameTemplate || environments[0]?.title || '');
     // Whether the runtim name has been changed by the user or not
     const [hasCustomRuntimeName, setHasCustomRuntimeName] = useState(false);
     const [userStorage, setUserStorage] = useState(false);
@@ -75,7 +75,7 @@ export function RuntimeLauncherDialog(props) {
         setSelection(selection);
         if (!hasCustomRuntimeName) {
             const spec = environments.find(env => env.name === selection);
-            setRuntimeName(spec?.kernel?.givenNameTemplate || spec?.title || '');
+            setRuntimeName(spec?.runtime?.givenNameTemplate || spec?.title || '');
         }
     }, [setSelection, hasCustomRuntimeName]);
     const handleSubmitRuntime = useCallback(async () => {

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

@@ -2,7 +2,7 @@ import { ReactElement, ReactNode } from 'react';
 import { ISessionContext } from '@jupyterlab/apputils';
 import { ITranslator } from '@jupyterlab/translation';
 import { IRuntimeDesc } from '../../models';
-import { IMultiServiceManager } from '../../sdk/stateful/runtimes';
+import { IMultiServiceManager } from '../../stateful/runtimes';
 type IDisplayMode = 'menu' | 'radio';
 /**
  * {@link RuntimePickerBase} properties

package/lib/components/runtimes/RuntimePickerBase.js

@@ -12,7 +12,7 @@ import { Box } from '@datalayer/primer-addons';
 import { CpuIcon } from '@primer/octicons-react';
 import { BrowserIcon, LaptopSimpleIcon } from '@datalayer/icons-react';
 import { CreditsIndicator } from '../../components/progress';
-import { isRuntimeRemote, } from '../../sdk/stateful/runtimes';
+import { isRuntimeRemote } from '../../stateful/runtimes';
 import { getGroupedRuntimeDescs } from './RuntimeUtils';
 /**
  * Maximal runtime display name length after which it is trimmed.

package/lib/components/runtimes/RuntimePickerCell.js

@@ -8,8 +8,8 @@ import { nullTranslator } from '@jupyterlab/translation';
 import { ActionList } from '@primer/react';
 import { CloudUploadIcon } from '@datalayer/icons-react';
 import { useCoreStore, useIAMStore } from '../../state';
-import { isRuntimeRemote } from '../../sdk/stateful/runtimes';
-import { RuntimeSnippetsFacade } from '../../sdk/stateful/jupyter';
+import { isRuntimeRemote } from '../../stateful/runtimes';
+import { RuntimeSnippetsFacade } from '../../stateful/jupyter';
 import { ExternalTokenSilentLogin } from '../../components/iam';
 import { SnippetDialog } from './../snippets/SnippetDialog';
 import { RuntimeLauncherDialog } from './RuntimeLauncherDialog';
@@ -61,7 +61,7 @@ export function RuntimePickerCell(props) {
     }, [preference]);
     const setSelectedRuntimeDesc = useCallback((kernel) => {
         const datalayerMeta = model.getMetadata('datalayer') ?? {
-            kernel: undefined,
+            runtime: undefined,
         };
         if (!kernel) {
             delete datalayerMeta.kernel;

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

@@ -1,6 +1,6 @@
 import { ITranslator } from '@jupyterlab/translation';
 import { CommandRegistry } from '@lumino/commands';
-import type { IMultiServiceManager, IDatalayerSessionContext } from '../../sdk/stateful/runtimes';
+import type { IMultiServiceManager, IDatalayerSessionContext } from '../../stateful/runtimes';
 import { RuntimeTransfer } from './RuntimeTransfer';
 /**
  * {@link RuntimePickerNotebook} properties

package/lib/components/runtimes/RuntimePickerNotebook.js

@@ -9,7 +9,7 @@ import { Box } from '@datalayer/primer-addons';
 import { AlertIcon } from '@primer/octicons-react';
 import { JSONExt } from '@lumino/coreutils';
 import { KernelExecutor } from '@datalayer/jupyter-react';
-import { RuntimeSnippetsFacade } from '../../sdk/stateful/jupyter';
+import { RuntimeSnippetsFacade } from '../../stateful/jupyter';
 import { ExternalTokenSilentLogin } from '../../components/iam';
 import { useCoreStore, useIAMStore } from '../../state';
 import { RuntimeReservationControl, MAXIMAL_RUNTIME_TIME_RESERVATION_MINUTES, } from './RuntimeReservationControl';
@@ -120,7 +120,7 @@ export function RuntimePickerNotebook(props) {
             : undefined;
         setValue(creditsLimit !== 0
             ? {
-                kernel: selectedRuntimeDesc
+                runtime: selectedRuntimeDesc
                     ? {
                         environmentName: ['browser', 'remote'].includes(selectedRuntimeDesc.location)
                             ? `${selectedRuntimeDesc.location}-${selectedRuntimeDesc.name}`

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

@@ -1,9 +1,9 @@
-import { type IRuntimeOptions } from '../../sdk/stateful/runtimes';
+import { type IRuntimeOptions } from '../../stateful/runtimes';
 export interface RuntimeTransfer {
     /**
      * Selected Kernel.
      */
-    kernel: Partial<Omit<IRuntimeOptions, 'kernelType'> & {
+    runtime: Partial<Omit<IRuntimeOptions, 'kernelType'> & {
         id: string;
     }> | null;
     /**