@datalayer/core 0.0.9 → 0.0.11

package/lib/api/types/spacer.d.ts

@@ -0,0 +1,271 @@
+/**
+ * Represents a workspace or project space in Datalayer
+ * @interface Space
+ */
+export interface Space {
+    id?: string;
+    uid: string;
+    name?: string;
+    name_t?: string;
+    handle_s?: string;
+    variant_s?: string;
+    description?: string;
+    description_t?: string;
+    visibility?: 'public' | 'private' | 'organization';
+    owner_id?: string;
+    organization_id?: string;
+    created_at?: string;
+    updated_at?: string;
+    creation_ts_dt?: string;
+    last_update_ts_dt?: string;
+    notebooks_count?: number;
+    members_count?: number;
+    tags?: string[];
+    tags_ss?: string[];
+    items?: any[];
+    members?: any[];
+}
+/**
+ * Represents a Jupyter notebook document
+ * @interface Notebook
+ */
+export interface Notebook {
+    id: string;
+    uid: string;
+    name?: string;
+    name_t?: string;
+    path?: string;
+    content?: any;
+    space_id?: string;
+    owner_id?: string;
+    creator_uid?: string;
+    creator_handle_s?: string;
+    created_at?: string;
+    creation_ts_dt?: string;
+    updated_at?: string;
+    last_update_ts_dt?: string;
+    version?: number;
+    kernel_spec?: any;
+    metadata?: Record<string, any>;
+    type_s?: string;
+    public_b?: boolean;
+    description_t?: string;
+    notebook_name_s?: string;
+    notebook_extension_s?: string;
+    notebook_format_s?: string;
+    content_length_i?: number;
+    content_type_s?: string;
+    mime_type_s?: string;
+    s3_path_s?: string;
+    s3_url_s?: string;
+    cdn_url_s?: string;
+    model_s?: string;
+}
+/**
+ * Represents a single cell in a Jupyter notebook
+ * @interface Cell
+ */
+export interface Cell {
+    id: string;
+    cell_type: 'code' | 'markdown' | 'raw';
+    source: string | string[];
+    outputs?: any[];
+    execution_count?: number | null;
+    metadata?: Record<string, any>;
+}
+/**
+ * Request payload for creating a new space
+ * @interface CreateSpaceRequest
+ */
+export interface CreateSpaceRequest {
+    name: string;
+    description: string;
+    variant: string;
+    spaceHandle: string;
+    organizationId: string;
+    seedSpaceId: string;
+    public: boolean;
+}
+/**
+ * Response from creating a space
+ * @interface CreateSpaceResponse
+ */
+export interface CreateSpaceResponse {
+    success: boolean;
+    message: string;
+    space: Space;
+}
+/**
+ * Request payload for creating a new notebook (multipart/form-data)
+ * @interface CreateNotebookRequest
+ */
+export interface CreateNotebookRequest {
+    spaceId: string;
+    notebookType: string;
+    name: string;
+    description: string;
+    file?: File | Blob;
+}
+/**
+ * Response from creating a notebook
+ * @interface CreateNotebookResponse
+ */
+export interface CreateNotebookResponse {
+    success: boolean;
+    message: string;
+    notebook: Notebook;
+}
+/**
+ * Response from getting a notebook
+ * @interface GetNotebookResponse
+ */
+export interface GetNotebookResponse {
+    success: boolean;
+    message: string;
+    notebook?: Notebook;
+}
+/**
+ * Request payload for creating a notebook
+ * @interface CreateNotebookRequest
+ */
+export interface CreateNotebookRequest {
+    spaceId: string;
+    notebookType: string;
+    name: string;
+    description: string;
+    file?: File | Blob;
+}
+/**
+ * Request payload for updating a notebook
+ * @interface UpdateNotebookRequest
+ */
+export interface UpdateNotebookRequest {
+    name?: string;
+    description?: string;
+}
+/**
+ * Response from updating a notebook
+ * @interface UpdateNotebookResponse
+ */
+export interface UpdateNotebookResponse {
+    success: boolean;
+    message: string;
+    notebook: Notebook;
+}
+/**
+ * Represents an item within a space
+ * @interface SpaceItem
+ */
+export interface SpaceItem {
+    id: string;
+    type: 'notebook' | 'lexical' | 'cell';
+    space_id: string;
+    item_id: string;
+    name: string;
+    created_at: string;
+    updated_at?: string;
+}
+/**
+ * Represents a Lexical document (rich text editor)
+ * @interface Lexical
+ */
+export interface Lexical {
+    id: string;
+    uid: string;
+    name?: string;
+    name_t?: string;
+    content?: any;
+    space_id?: string;
+    owner_id?: string;
+    creator_uid?: string;
+    creator_handle_s?: string;
+    created_at?: string;
+    creation_ts_dt?: string;
+    updated_at?: string;
+    last_update_ts_dt?: string;
+    type_s?: string;
+    public_b?: boolean;
+    description_t?: string;
+    document_name_s?: string;
+    document_extension_s?: string;
+    document_format_s?: string;
+    content_length_i?: number;
+    content_type_s?: string;
+    mime_type_s?: string;
+    s3_path_s?: string;
+    s3_url_s?: string;
+    cdn_url_s?: string;
+    model_s?: string;
+}
+/**
+ * Request payload for creating a Lexical document
+ * @interface CreateLexicalRequest
+ */
+export interface CreateLexicalRequest {
+    spaceId: string;
+    documentType: string;
+    name: string;
+    description: string;
+    file?: File | Blob;
+}
+/**
+ * Response from creating a Lexical document
+ * @interface CreateLexicalResponse
+ */
+export interface CreateLexicalResponse {
+    success: boolean;
+    message: string;
+    document: Lexical;
+}
+/**
+ * Response from getting a Lexical document
+ * @interface GetLexicalResponse
+ */
+export interface GetLexicalResponse {
+    success: boolean;
+    message: string;
+    document?: Lexical;
+}
+/**
+ * Request payload for updating a Lexical document
+ * @interface UpdateLexicalRequest
+ */
+export interface UpdateLexicalRequest {
+    name?: string;
+    description?: string;
+}
+/**
+ * Response from updating a Lexical document
+ * @interface UpdateLexicalResponse
+ */
+export interface UpdateLexicalResponse {
+    success: boolean;
+    message: string;
+    document: Lexical;
+}
+/**
+ * Response from getting space items
+ * @interface GetSpaceItemsResponse
+ */
+export interface GetSpaceItemsResponse {
+    success: boolean;
+    message: string;
+    items: SpaceItem[];
+}
+/**
+ * Response from deleting a space item
+ * @interface DeleteSpaceItemResponse
+ */
+export interface DeleteSpaceItemResponse {
+    success: boolean;
+    message: string;
+}
+/**
+ * Response from getting spaces for a user
+ * @interface SpacesForUserResponse
+ */
+export interface SpacesForUserResponse {
+    success: boolean;
+    message: string;
+    spaces: Space[];
+}

package/lib/api/types/spacer.js

@@ -0,0 +1,5 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+export {};

package/lib/api/utils/__tests__/validation.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/api/utils/__tests__/validation.test.js

@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { describe, it, expect } from 'vitest';
+import { validateToken, validateRequired, validateRequiredString, } from '../validation';
+describe('validation utilities', () => {
+    describe('validateToken', () => {
+        const validToken = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyLCJleHAiOjk5OTk5OTk5OTl9.Vg30C57s3l90JNap_VgMhKZjfc-p7SoBXaSAy8c6BS8';
+        it('should accept valid JWT tokens', () => {
+            expect(() => validateToken(validToken)).not.toThrow();
+        });
+        it('should reject null or undefined tokens', () => {
+            expect(() => validateToken(null)).toThrow('Authentication token is required');
+            expect(() => validateToken(undefined)).toThrow('Authentication token is required');
+        });
+        it('should reject empty or whitespace tokens', () => {
+            expect(() => validateToken('')).toThrow('Authentication token is required');
+            expect(() => validateToken('  ')).toThrow('Authentication token is required');
+        });
+        it('should reject tokens without three parts', () => {
+            expect(() => validateToken('part1.part2')).toThrow('Invalid token format: JWT must have three parts separated by dots');
+            expect(() => validateToken('part1.part2.part3.part4')).toThrow('Invalid token format: JWT must have three parts separated by dots');
+            expect(() => validateToken('singlepart')).toThrow('Invalid token format: JWT must have three parts separated by dots');
+        });
+        it('should reject tokens with empty parts', () => {
+            expect(() => validateToken('.part2.part3')).toThrow('Invalid token format: Part 1 is empty');
+            expect(() => validateToken('part1..part3')).toThrow('Invalid token format: Part 2 is empty');
+            expect(() => validateToken('part1.part2.')).toThrow('Invalid token format: Part 3 is empty');
+        });
+        it('should reject tokens with invalid Base64URL characters', () => {
+            const invalidCharToken = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWI!@#$.Vg30C57s3l90JNap_VgMhKZjfc-p7SoBXaSAy8c6BS8';
+            expect(() => validateToken(invalidCharToken)).toThrow('Invalid token format: Part 2 contains invalid characters');
+        });
+        it('should reject tokens that are too short', () => {
+            const shortToken = 'eyJ0eXAiOiJKV1QifQ.eyJzdWIiOiIxIn0.signature';
+            expect(() => validateToken(shortToken)).toThrow('Invalid token format: Token is too short to be a valid JWT');
+        });
+        it('should reject tokens that are too long', () => {
+            const header = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9';
+            const payload = 'a'.repeat(4000);
+            const signature = 'b'.repeat(1000);
+            const longToken = `${header}.${payload}.${signature}`;
+            expect(() => validateToken(longToken)).toThrow('Invalid token format: Token exceeds maximum expected length');
+        });
+        it('should reject tokens with invalid JWT header', () => {
+            const invalidHeaderToken = 'notbase64.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.signature123456789012345';
+            expect(() => validateToken(invalidHeaderToken)).toThrow('Invalid token format: JWT header is not valid base64-encoded JSON');
+        });
+        it('should reject tokens with missing algorithm in header', () => {
+            // This token has valid JSON header but missing 'alg' field
+            const noAlgToken = 'eyJ0eXAiOiJKV1QifQ.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyLCJleHAiOjk5OTk5OTk5OTl9.signature123456789012345678901234567890';
+            expect(() => validateToken(noAlgToken)).toThrow('Invalid token format: Missing algorithm in JWT header');
+        });
+        it('should reject tokens with invalid JWT payload', () => {
+            // This token has enough length but invalid base64 in payload
+            const invalidPayloadToken = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.notvalidbase64jsonbutlongenoughtopasslengthchecknotvalidbase64jsonbutlongenough.signature123456789012345678901234567890';
+            expect(() => validateToken(invalidPayloadToken)).toThrow('Invalid token format: JWT payload is not valid base64-encoded JSON');
+        });
+        it('should reject expired tokens', () => {
+            const expiredToken = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyLCJleHAiOjE1MTYyMzkwMjJ9.4Adcj3UFYzPUVaVF43FmMab6RlaQD8A9V8wFzzht-KQ';
+            expect(() => validateToken(expiredToken)).toThrow('Token has expired');
+        });
+        it('should reject tokens not yet valid (nbf claim)', () => {
+            const futureToken = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyLCJuYmYiOjk5OTk5OTk5OTl9.UGLFIRACvGl-MiFpZmAiDuVm7br9tBTxMOqb4sjN-jg';
+            expect(() => validateToken(futureToken)).toThrow('Token is not yet valid');
+        });
+        it('should reject tokens with signature that is too short', () => {
+            const shortSigToken = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.short';
+            expect(() => validateToken(shortSigToken)).toThrow('Invalid token format: JWT signature is too short');
+        });
+        it('should trim whitespace from tokens', () => {
+            const tokenWithWhitespace = `  ${validToken}  `;
+            expect(() => validateToken(tokenWithWhitespace)).not.toThrow();
+        });
+    });
+    describe('validateRequired', () => {
+        it('should accept valid values', () => {
+            expect(() => validateRequired('value', 'param')).not.toThrow();
+            expect(() => validateRequired(0, 'param')).not.toThrow();
+            expect(() => validateRequired(false, 'param')).not.toThrow();
+            expect(() => validateRequired('', 'param')).not.toThrow();
+        });
+        it('should reject null values', () => {
+            expect(() => validateRequired(null, 'param')).toThrow('param is required');
+        });
+        it('should reject undefined values', () => {
+            expect(() => validateRequired(undefined, 'param')).toThrow('param is required');
+        });
+    });
+    describe('validateRequiredString', () => {
+        it('should accept valid strings', () => {
+            expect(() => validateRequiredString('value', 'param')).not.toThrow();
+            expect(() => validateRequiredString('  value  ', 'param')).not.toThrow();
+        });
+        it('should reject null values', () => {
+            expect(() => validateRequiredString(null, 'param')).toThrow('param is required');
+        });
+        it('should reject undefined values', () => {
+            expect(() => validateRequiredString(undefined, 'param')).toThrow('param is required');
+        });
+        it('should reject empty strings', () => {
+            expect(() => validateRequiredString('', 'param')).toThrow('param is required');
+        });
+        it('should reject whitespace-only strings', () => {
+            expect(() => validateRequiredString('   ', 'param')).toThrow('param is required');
+        });
+    });
+});

package/lib/api/utils/validation.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @module api/utils/validation
+ * @description Utility functions for API parameter validation
+ */
+/**
+ * Validates that an authentication token is provided and is a valid JWT format
+ * @param token - The authentication token to validate
+ * @throws {Error} If the token is missing, null, undefined, empty/whitespace, or not a valid JWT format
+ */
+export declare const validateToken: (token: string | undefined | null) => void;
+/**
+ * Validates that a required parameter is provided
+ * @param value - The value to validate
+ * @param paramName - The name of the parameter for error messages
+ * @throws {Error} If the value is missing, null, or undefined
+ */
+export declare const validateRequired: (value: any, paramName: string) => void;
+/**
+ * Validates that a string parameter is provided and not empty
+ * @param value - The string value to validate
+ * @param paramName - The name of the parameter for error messages
+ * @throws {Error} If the value is missing, null, undefined, or empty/whitespace
+ */
+export declare const validateRequiredString: (value: string | undefined | null, paramName: string) => void;

package/lib/api/utils/validation.js

@@ -0,0 +1,133 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * @module api/utils/validation
+ * @description Utility functions for API parameter validation
+ */
+/**
+ * Validates that an authentication token is provided and is a valid JWT format
+ * @param token - The authentication token to validate
+ * @throws {Error} If the token is missing, null, undefined, empty/whitespace, or not a valid JWT format
+ */
+export const validateToken = (token) => {
+    // Check if token exists and is not empty
+    if (!token || !token.trim()) {
+        throw new Error('Authentication token is required');
+    }
+    const trimmedToken = token.trim();
+    // JWT should have three parts separated by dots (header.payload.signature)
+    const parts = trimmedToken.split('.');
+    if (parts.length !== 3) {
+        throw new Error('Invalid token format: JWT must have three parts separated by dots');
+    }
+    // Check each part is Base64URL encoded (contains only valid characters)
+    const base64UrlRegex = /^[A-Za-z0-9_-]+$/;
+    for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        // Each part should not be empty
+        if (!part || part.length === 0) {
+            throw new Error(`Invalid token format: Part ${i + 1} is empty`);
+        }
+        // Check for valid Base64URL characters
+        if (!base64UrlRegex.test(part)) {
+            throw new Error(`Invalid token format: Part ${i + 1} contains invalid characters`);
+        }
+    }
+    // Check reasonable length constraints
+    // JWT tokens are typically 100-2000 characters depending on claims
+    if (trimmedToken.length < 100) {
+        throw new Error('Invalid token format: Token is too short to be a valid JWT');
+    }
+    if (trimmedToken.length > 5000) {
+        throw new Error('Invalid token format: Token exceeds maximum expected length');
+    }
+    // Validate header structure (should be valid base64url JSON)
+    try {
+        // Use Buffer for Node.js compatibility or atob for browser
+        const headerBase64 = parts[0].replace(/-/g, '+').replace(/_/g, '/');
+        const headerString = typeof Buffer !== 'undefined'
+            ? Buffer.from(headerBase64, 'base64').toString()
+            : atob(headerBase64);
+        const header = JSON.parse(headerString);
+        // Check for required JWT header fields
+        if (!header.alg) {
+            throw new Error('Invalid token format: Missing algorithm in JWT header');
+        }
+        if (!header.typ && !header.cty) {
+            // typ is optional but common, if missing there should be at least some type indication
+            console.warn('JWT header missing "typ" field, which is recommended');
+        }
+    }
+    catch (e) {
+        if (e instanceof Error &&
+            e.message === 'Invalid token format: Missing algorithm in JWT header') {
+            throw e;
+        }
+        throw new Error('Invalid token format: JWT header is not valid base64-encoded JSON');
+    }
+    // Validate payload structure (should be valid base64url JSON)
+    try {
+        // Use Buffer for Node.js compatibility or atob for browser
+        const payloadBase64 = parts[1].replace(/-/g, '+').replace(/_/g, '/');
+        const payloadString = typeof Buffer !== 'undefined'
+            ? Buffer.from(payloadBase64, 'base64').toString()
+            : atob(payloadBase64);
+        const payload = JSON.parse(payloadString);
+        // Check for common JWT claims (at least one should typically be present)
+        const commonClaims = ['iss', 'sub', 'aud', 'exp', 'nbf', 'iat', 'jti'];
+        const hasCommonClaim = commonClaims.some(claim => payload[claim] !== undefined);
+        if (!hasCommonClaim) {
+            console.warn('JWT payload missing common claims, token may be non-standard');
+        }
+        // If exp (expiration) exists, check if token is expired
+        if (payload.exp) {
+            const now = Math.floor(Date.now() / 1000);
+            if (payload.exp < now) {
+                throw new Error('Token has expired');
+            }
+        }
+        // If nbf (not before) exists, check if token is not yet valid
+        if (payload.nbf) {
+            const now = Math.floor(Date.now() / 1000);
+            if (payload.nbf > now) {
+                throw new Error('Token is not yet valid');
+            }
+        }
+    }
+    catch (e) {
+        if (e instanceof Error &&
+            (e.message === 'Token has expired' ||
+                e.message === 'Token is not yet valid')) {
+            throw e;
+        }
+        throw new Error('Invalid token format: JWT payload is not valid base64-encoded JSON');
+    }
+    // Signature part validation (just check it exists and has reasonable length)
+    if (parts[2].length < 20) {
+        throw new Error('Invalid token format: JWT signature is too short');
+    }
+};
+/**
+ * Validates that a required parameter is provided
+ * @param value - The value to validate
+ * @param paramName - The name of the parameter for error messages
+ * @throws {Error} If the value is missing, null, or undefined
+ */
+export const validateRequired = (value, paramName) => {
+    if (value === null || value === undefined) {
+        throw new Error(`${paramName} is required`);
+    }
+};
+/**
+ * Validates that a string parameter is provided and not empty
+ * @param value - The string value to validate
+ * @param paramName - The name of the parameter for error messages
+ * @throws {Error} If the value is missing, null, undefined, or empty/whitespace
+ */
+export const validateRequiredString = (value, paramName) => {
+    if (!value || !value.trim()) {
+        throw new Error(`${paramName} is required`);
+    }
+};

package/lib/components/display/JupyterDialog.js

@@ -59,13 +59,9 @@ export class JupyterDialog extends ReactWidget {
         }) }));
     _renderFooter = (props) => (_jsx(DialogFooter, { ...props, checkbox: this.checkbox, setChecked: this.setChecked }));
     render() {
-        return (_jsx(JupyterReactTheme, { children: _jsx(PrimerDialog, { sx: {
-                    color: 'var(--fgColor-default)',
-                    backgroundColor: 'var(--bgColor-default)',
-                    fontFamily: 'var(--fontStack-system)',
-                    fontSize: 'var(--text-body-size-medium)',
-                    lineHeight: 'var(--text-body-lineHeight-medium)',
-                }, onClose: this.close, footerButtons: this.buttons.map((but, idx) => {
+        // TODO title color is enforced for JupyterLab.
+        // This may be fixed in the jupyter-react theme (Primer generates h1 for the dialog title).
+        return (_jsx(JupyterReactTheme, { children: _jsx(PrimerDialog, { title: _jsx("span", { style: { color: 'var(--fgColor-default)' }, children: this.dialogTitle }), onClose: this.close, renderBody: this._renderBody, renderFooter: this._renderFooter, footerButtons: this.buttons.map((but, idx) => {
                     const footerButton = {
                         buttonType: but.displayType === 'default'
                             ? but.accept
@@ -80,7 +76,7 @@ export class JupyterDialog extends ReactWidget {
                         autoFocus: but.accept,
                     };
                     return footerButton;
-                }), renderBody: this._renderBody, renderFooter: this._renderFooter, title: this.dialogTitle }) }));
+                }) }) }));
     }
     /**
      * Launch the dialog as a modal window.

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

@@ -1,4 +1,4 @@
-import type { IRemoteServicesManager } from '../../api';
+import type { IRemoteServicesManager } from '../../sdk/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 '../../api';
+import { RuntimeSnippetsFacade } from '../../sdk/stateful/jupyter';
 import { RuntimeCellVariables } from './RuntimeCellVariables';
 /**
  * Dialog to define the runtime cell variables to transfer
@@ -84,7 +84,7 @@ export function RuntimeCellVariablesDialog(props) {
             title += ` with ${kernelName}`;
         }
     }
-    return (_jsx(Dialog, { title: title, onClose: onClose, footerButtons: [
+    return (_jsx(Dialog, { title: _jsx("span", { style: { color: 'var(--fgColor-default)' }, children: title }), onClose: onClose, footerButtons: [
             {
                 buttonType: 'default',
                 content: trans.__('Cancel'),

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

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

package/lib/components/runtimes/RuntimeLauncherDialog.js

@@ -46,7 +46,8 @@ export function RuntimeLauncherDialog(props) {
         // TODO when would this component be shown outside of a react-router? navigation is only available within a react-router.
         console.warn(reason);
     }
-    const { jupyterLabAdapter } = useJupyterReactStore();
+    const jupyterReactStore = useJupyterReactStore();
+    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 || '');
@@ -211,7 +212,9 @@ export function RuntimeLauncherDialog(props) {
             setHasCustomRuntimeName(true);
         }
     }, []);
-    return (_jsx(Dialog, { title: dialogTitle || 'Launch a new Runtime', onClose: () => {
+    // TODO title color is enforced for JupyterLab.
+    // This may be fixed in the jupyter-react theme (Primer generates h1 for the dialog title).
+    return (_jsx(Dialog, { title: _jsx("span", { style: { color: 'var(--fgColor-default)' }, children: dialogTitle || 'Launch a new Runtime' }), onClose: () => {
             onSubmit(undefined);
         }, footerButtons: [
             {

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 '../../api';
+import { IMultiServiceManager } from '../../sdk/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 '../../api';
+import { isRuntimeRemote, } from '../../sdk/stateful/runtimes';
 import { getGroupedRuntimeDescs } from './RuntimeUtils';
 /**
  * Maximal runtime display name length after which it is trimmed.

package/lib/components/runtimes/RuntimePickerCell.js

@@ -8,7 +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, RuntimeSnippetsFacade } from '../../api';
+import { isRuntimeRemote } from '../../sdk/stateful/runtimes';
+import { RuntimeSnippetsFacade } from '../../sdk/stateful/jupyter';
 import { ExternalTokenSilentLogin } from '../../components/iam';
 import { SnippetDialog } from './../snippets/SnippetDialog';
 import { RuntimeLauncherDialog } from './RuntimeLauncherDialog';

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 '../../api';
+import type { IMultiServiceManager, IDatalayerSessionContext } from '../../sdk/stateful/runtimes';
 import { RuntimeTransfer } from './RuntimeTransfer';
 /**
  * {@link RuntimePickerNotebook} properties