@datalayer/core 1.0.3 → 1.0.11

package/lib/api/constants.d.ts

@@ -2,6 +2,7 @@
  * API base paths for different service domains
  */
 export declare const API_BASE_PATHS: {
+    readonly AI_AGENTS: "/api/ai-agents/v1";
     readonly IAM: "/api/iam/v1";
     readonly OTEL: "/api/otel/v1";
     readonly RUNTIMES: "/api/runtimes/v1";
@@ -11,6 +12,8 @@ export declare const API_BASE_PATHS: {
  * Default service URLs for the Datalayer platform
  */
 export declare const DEFAULT_SERVICE_URLS: {
+    /** Default URL for AI Agents (durable agent management) service */
+    readonly AI_AGENTS: "https://prod1.datalayer.run";
     /** Default URL for IAM (Identity and Access Management) service */
     readonly IAM: "https://prod1.datalayer.run";
     /** Default URL for OTEL (OpenTelemetry observability) service */

package/lib/api/constants.js

@@ -6,6 +6,7 @@
  * API base paths for different service domains
  */
 export const API_BASE_PATHS = {
+    AI_AGENTS: '/api/ai-agents/v1',
     IAM: '/api/iam/v1',
     OTEL: '/api/otel/v1',
     RUNTIMES: '/api/runtimes/v1',
@@ -15,6 +16,8 @@ export const API_BASE_PATHS = {
  * Default service URLs for the Datalayer platform
  */
 export const DEFAULT_SERVICE_URLS = {
+    /** Default URL for AI Agents (durable agent management) service */
+    AI_AGENTS: 'https://prod1.datalayer.run',
     /** Default URL for IAM (Identity and Access Management) service */
     IAM: 'https://prod1.datalayer.run',
     /** Default URL for OTEL (OpenTelemetry observability) service */

package/lib/api/runtimes/checkpoints.d.ts

@@ -0,0 +1,122 @@
+/**
+ * A single runtime checkpoint record.
+ */
+export interface RuntimeCheckpointData {
+    /** Unique identifier (ULID) */
+    id: string;
+    /** Human-readable name */
+    name: string;
+    /** Checkpoint description */
+    description: string;
+    /** Runtime that was checkpointed */
+    runtime_uid: string;
+    /** Agent spec identifier (e.g. "mocks/monitor-sales-kpis") */
+    agent_spec_id: string;
+    /** Full agent spec payload */
+    agentspec: Record<string, any>;
+    /** Additional metadata */
+    metadata: Record<string, any>;
+    /** Checkpoint mode: criu (full) or light (history-only) */
+    checkpoint_mode?: 'criu' | 'light';
+    /** Lightweight checkpoint message history */
+    messages?: string[];
+    /** Status: requested | created | failed | deleted */
+    status: string;
+    /** Human-readable details about the current status (e.g. error message) */
+    status_message?: string;
+    /** ISO 8601 timestamp */
+    updated_at: string;
+}
+/**
+ * Request payload for creating a checkpoint.
+ */
+export interface CreateRuntimeCheckpointRequest {
+    /** Runtime UID of the runtime that was checkpointed */
+    runtime_uid: string;
+    /** Human-readable name */
+    name?: string;
+    /** Checkpoint description */
+    description?: string;
+    /** Agent spec identifier */
+    agentspec_id?: string;
+    /** Full agent spec payload to persist */
+    agentspec?: Record<string, any>;
+    /** Additional metadata */
+    metadata?: Record<string, any>;
+}
+/**
+ * Response for listing checkpoints.
+ */
+export interface ListRuntimeCheckpointsResponse {
+    success: boolean;
+    message: string;
+    checkpoints: RuntimeCheckpointData[];
+}
+/**
+ * Response for getting a single checkpoint.
+ */
+export interface GetRuntimeCheckpointResponse {
+    success: boolean;
+    message: string;
+    checkpoint: RuntimeCheckpointData;
+}
+/**
+ * Response for creating a checkpoint.
+ */
+export interface CreateRuntimeCheckpointResponse {
+    success: boolean;
+    message: string;
+    checkpoint: RuntimeCheckpointData;
+}
+/**
+ * List runtime checkpoints for a specific runtime.
+ * @param token - Authentication token
+ * @param baseUrl - Base URL for the runtimes API
+ * @param runtimeUid - Runtime UID to list checkpoints for
+ * @returns Promise resolving to list of checkpoints
+ */
+export declare const listCheckpoints: (token: string, baseUrl?: string, runtimeUid?: string) => Promise<ListRuntimeCheckpointsResponse>;
+/**
+ * Get a single runtime checkpoint by ID.
+ * @param token - Authentication token
+ * @param runtimeUid - The runtime UID
+ * @param checkpointId - The checkpoint ID (ULID)
+ * @param baseUrl - Base URL for the runtimes API
+ * @returns Promise resolving to checkpoint details
+ */
+export declare const getCheckpoint: (token: string, runtimeUid: string, checkpointId: string, baseUrl?: string) => Promise<GetRuntimeCheckpointResponse>;
+/**
+ * Create a checkpoint record (after a CRIU checkpoint has been taken).
+ * @param token - Authentication token
+ * @param data - Checkpoint creation payload (runtime_uid, agentspec, etc.)
+ * @param baseUrl - Base URL for the runtimes API
+ * @returns Promise resolving to the created checkpoint
+ */
+export declare const createCheckpoint: (token: string, data: CreateRuntimeCheckpointRequest, baseUrl?: string) => Promise<CreateRuntimeCheckpointResponse>;
+/**
+ * Poll a checkpoint until it reaches one of the target statuses.
+ *
+ * Useful for waiting until an async pause (status "paused")
+ * completes before proceeding.  Checkpoint status stays "paused"
+ * during resume — only the agent runtime status transitions.
+ *
+ * @param token - Authentication token
+ * @param runtimeUid - The runtime UID that owns the checkpoint
+ * @param checkpointId - The checkpoint ID (ULID) to poll
+ * @param targetStatuses - Set of statuses that signal completion (e.g. ["paused", "failed"])
+ * @param baseUrl - Base URL for the runtimes API
+ * @param intervalMs - Polling interval in milliseconds (default: 2000)
+ * @param timeoutMs - Maximum wait time in milliseconds (default: 600000 = 10 min)
+ * @returns Promise resolving to the checkpoint data once a target status is reached
+ * @throws {Error} If polling times out or the request fails
+ */
+export declare const waitForCheckpointStatus: (token: string, runtimeUid: string, checkpointId: string, targetStatuses: string[], baseUrl?: string, intervalMs?: number, timeoutMs?: number) => Promise<RuntimeCheckpointData>;
+/**
+ * Delete a runtime checkpoint.
+ * @param token - Authentication token
+ * @param runtimeUid - The runtime UID that owns the checkpoint
+ * @param checkpointId - The checkpoint ID (ULID) to delete
+ * @param baseUrl - Base URL for the runtimes API
+ * @returns Promise resolving when deletion is complete
+ */
+export declare const deleteCheckpoint: (token: string, runtimeUid: string, checkpointId: string, baseUrl?: string) => Promise<void>;

package/lib/api/runtimes/checkpoints.js

@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * Runtime checkpoints API functions for the Datalayer platform.
+ *
+ * Provides functions for managing CRIU full-pod checkpoints.
+ * These are distinct from runtime snapshots (Jupyter sandbox snapshots).
+ *
+ * @module api/runtimes/checkpoints
+ */
+import { requestDatalayerAPI } from '../DatalayerApi';
+import { API_BASE_PATHS, DEFAULT_SERVICE_URLS } from '../constants';
+import { validateToken, validateRequiredString } from '../utils/validation';
+// ─── API Functions ─────────────────────────────────────────────────────────
+/**
+ * List runtime checkpoints for a specific runtime.
+ * @param token - Authentication token
+ * @param baseUrl - Base URL for the runtimes API
+ * @param runtimeUid - Runtime UID to list checkpoints for
+ * @returns Promise resolving to list of checkpoints
+ */
+export const listCheckpoints = async (token, baseUrl = DEFAULT_SERVICE_URLS.RUNTIMES, runtimeUid) => {
+    validateToken(token);
+    if (!runtimeUid) {
+        throw new Error('runtimeUid is required to list checkpoints');
+    }
+    return requestDatalayerAPI({
+        url: `${baseUrl}${API_BASE_PATHS.RUNTIMES}/runtime-checkpoints/${encodeURIComponent(runtimeUid)}`,
+        method: 'GET',
+        token,
+    });
+};
+/**
+ * Get a single runtime checkpoint by ID.
+ * @param token - Authentication token
+ * @param runtimeUid - The runtime UID
+ * @param checkpointId - The checkpoint ID (ULID)
+ * @param baseUrl - Base URL for the runtimes API
+ * @returns Promise resolving to checkpoint details
+ */
+export const getCheckpoint = async (token, runtimeUid, checkpointId, baseUrl = DEFAULT_SERVICE_URLS.RUNTIMES) => {
+    validateToken(token);
+    validateRequiredString(runtimeUid, 'Runtime UID');
+    validateRequiredString(checkpointId, 'Checkpoint ID');
+    return requestDatalayerAPI({
+        url: `${baseUrl}${API_BASE_PATHS.RUNTIMES}/runtime-checkpoints/${encodeURIComponent(runtimeUid)}/${checkpointId}`,
+        method: 'GET',
+        token,
+    });
+};
+/**
+ * Create a checkpoint record (after a CRIU checkpoint has been taken).
+ * @param token - Authentication token
+ * @param data - Checkpoint creation payload (runtime_uid, agentspec, etc.)
+ * @param baseUrl - Base URL for the runtimes API
+ * @returns Promise resolving to the created checkpoint
+ */
+export const createCheckpoint = async (token, data, baseUrl = DEFAULT_SERVICE_URLS.RUNTIMES) => {
+    validateToken(token);
+    return requestDatalayerAPI({
+        url: `${baseUrl}${API_BASE_PATHS.RUNTIMES}/runtime-checkpoints`,
+        method: 'POST',
+        token,
+        body: data,
+    });
+};
+/**
+ * Poll a checkpoint until it reaches one of the target statuses.
+ *
+ * Useful for waiting until an async pause (status "paused")
+ * completes before proceeding.  Checkpoint status stays "paused"
+ * during resume — only the agent runtime status transitions.
+ *
+ * @param token - Authentication token
+ * @param runtimeUid - The runtime UID that owns the checkpoint
+ * @param checkpointId - The checkpoint ID (ULID) to poll
+ * @param targetStatuses - Set of statuses that signal completion (e.g. ["paused", "failed"])
+ * @param baseUrl - Base URL for the runtimes API
+ * @param intervalMs - Polling interval in milliseconds (default: 2000)
+ * @param timeoutMs - Maximum wait time in milliseconds (default: 600000 = 10 min)
+ * @returns Promise resolving to the checkpoint data once a target status is reached
+ * @throws {Error} If polling times out or the request fails
+ */
+export const waitForCheckpointStatus = async (token, runtimeUid, checkpointId, targetStatuses, baseUrl = DEFAULT_SERVICE_URLS.RUNTIMES, intervalMs = 2000, timeoutMs = 600_000) => {
+    validateToken(token);
+    validateRequiredString(runtimeUid, 'Runtime UID');
+    validateRequiredString(checkpointId, 'Checkpoint ID');
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        const resp = await getCheckpoint(token, runtimeUid, checkpointId, baseUrl);
+        if (targetStatuses.includes(resp.checkpoint.status)) {
+            return resp.checkpoint;
+        }
+        // Wait before next poll
+        await new Promise(resolve => setTimeout(resolve, intervalMs));
+    }
+    throw new Error(`Checkpoint ${checkpointId} did not reach status [${targetStatuses.join(', ')}] within ${timeoutMs / 1000}s`);
+};
+/**
+ * Delete a runtime checkpoint.
+ * @param token - Authentication token
+ * @param runtimeUid - The runtime UID that owns the checkpoint
+ * @param checkpointId - The checkpoint ID (ULID) to delete
+ * @param baseUrl - Base URL for the runtimes API
+ * @returns Promise resolving when deletion is complete
+ */
+export const deleteCheckpoint = async (token, runtimeUid, checkpointId, baseUrl = DEFAULT_SERVICE_URLS.RUNTIMES) => {
+    validateToken(token);
+    validateRequiredString(runtimeUid, 'Runtime UID');
+    validateRequiredString(checkpointId, 'Checkpoint ID');
+    return requestDatalayerAPI({
+        url: `${baseUrl}${API_BASE_PATHS.RUNTIMES}/runtime-checkpoints/${encodeURIComponent(runtimeUid)}/${checkpointId}`,
+        method: 'DELETE',
+        token,
+    });
+};

package/lib/api/runtimes/index.d.ts

@@ -9,3 +9,4 @@ export * as environments from './environments';
 export * as healthz from './healthz';
 export * as runtimes from './runtimes';
 export * as snapshots from './snapshots';
+export * as checkpoints from './checkpoints';

package/lib/api/runtimes/index.js

@@ -13,3 +13,4 @@ export * as environments from './environments';
 export * as healthz from './healthz';
 export * as runtimes from './runtimes';
 export * as snapshots from './snapshots';
+export * as checkpoints from './checkpoints';

package/lib/api/runtimes/runtimes.d.ts

@@ -52,3 +52,87 @@ export declare const deleteRuntime: (token: string, podName: string, baseUrl?: s
  * @throws {Error} With status 404 if the runtime is not found
  */
 export declare const updateRuntime: (token: string, podName: string, from: string, baseUrl?: string) => Promise<RuntimeData>;
+/**
+ * Response from the pause/resume runtime endpoints.
+ * The server returns 202 Accepted and provides a checkpoint UID
+ * that can be polled for status updates.
+ */
+export interface PauseResumeResponse {
+    success: boolean;
+    message: string;
+    checkpoint_id: string | null;
+}
+/**
+ * Optional body for the pause endpoint.
+ * Metadata is stored in the checkpoint Solr record created by the backend.
+ */
+export interface PauseRuntimeBody {
+    /** Checkpoint mode: 'criu' (full) or 'light' (history-only) */
+    checkpoint_mode?: 'criu' | 'light';
+    /** Human-readable checkpoint name */
+    name?: string;
+    /** Checkpoint description */
+    description?: string;
+    /** Agent spec identifier */
+    agent_spec_id?: string;
+    /** Full agent spec payload to persist with the checkpoint */
+    agentspec?: Record<string, any>;
+    /** Additional metadata */
+    metadata?: Record<string, any>;
+    /** Lightweight checkpoint message history */
+    messages?: string[];
+}
+/**
+ * Pause a runtime by creating a checkpoint (async, light mode by default).
+ *
+ * Returns immediately with a 202 Accepted response.  The actual checkpoint
+ * process runs in the background.  Use the returned `checkpoint_id` to
+ * poll for status via the runtime-checkpoints API.
+ *
+ * @param token - Authentication token
+ * @param podName - The unique pod name of the runtime to pause
+ * @param baseUrl - Base URL for the API (defaults to production Runtimes URL)
+ * @param body - Optional metadata to store in the checkpoint record
+ * @returns Promise resolving with the checkpoint ID for status tracking
+ * @throws {Error} If authentication token is missing or invalid
+ * @throws {Error} If pod name is missing or invalid
+ */
+export declare const pauseRuntime: (token: string, podName: string, baseUrl?: string, body?: PauseRuntimeBody) => Promise<PauseResumeResponse>;
+/**
+ * Optional body for the resume endpoint.
+ * Contains information needed by the operator to restore from a checkpoint.
+ */
+export interface ResumeRuntimeBody {
+    /** Checkpoint mode to resume from: 'criu' or 'light' */
+    checkpoint_mode?: 'criu' | 'light';
+    /** Explicit checkpoint identifier */
+    checkpoint_id?: string;
+    /** Agent spec identifier (required by the operator for restore) */
+    agent_spec_id?: string;
+    /** Specific checkpoint timestamp to restore from */
+    checkpoint_timestamp?: string;
+    /** Environment name override */
+    environment_name?: string;
+    /** Container image override */
+    container_image?: string;
+    /** Target node name */
+    node_name?: string;
+    /** Additional metadata */
+    metadata?: Record<string, any>;
+}
+/**
+ * Resume a paused runtime by restoring from a checkpoint (async).
+ *
+ * Returns immediately with a 202 Accepted response.  The actual restore
+ * process runs in the background.  Use the returned `checkpoint_id` to
+ * poll for status.
+ *
+ * @param token - Authentication token
+ * @param podName - The unique pod name of the runtime to resume
+ * @param baseUrl - Base URL for the API (defaults to production Runtimes URL)
+ * @param body - Optional body with agent_spec_id and restore options
+ * @returns Promise resolving with the checkpoint ID for status tracking
+ * @throws {Error} If authentication token is missing or invalid
+ * @throws {Error} If pod name is missing or invalid
+ */
+export declare const resumeRuntime: (token: string, podName: string, baseUrl?: string, body?: ResumeRuntimeBody) => Promise<PauseResumeResponse>;

package/lib/api/runtimes/runtimes.js

@@ -178,3 +178,53 @@ export const updateRuntime = async (token, podName, from, baseUrl = DEFAULT_SERV
         throw error;
     }
 };
+/**
+ * Pause a runtime by creating a checkpoint (async, light mode by default).
+ *
+ * Returns immediately with a 202 Accepted response.  The actual checkpoint
+ * process runs in the background.  Use the returned `checkpoint_id` to
+ * poll for status via the runtime-checkpoints API.
+ *
+ * @param token - Authentication token
+ * @param podName - The unique pod name of the runtime to pause
+ * @param baseUrl - Base URL for the API (defaults to production Runtimes URL)
+ * @param body - Optional metadata to store in the checkpoint record
+ * @returns Promise resolving with the checkpoint ID for status tracking
+ * @throws {Error} If authentication token is missing or invalid
+ * @throws {Error} If pod name is missing or invalid
+ */
+export const pauseRuntime = async (token, podName, baseUrl = DEFAULT_SERVICE_URLS.RUNTIMES, body) => {
+    validateToken(token);
+    validateRequiredString(podName, 'Pod name');
+    return await requestDatalayerAPI({
+        url: `${baseUrl}${API_BASE_PATHS.RUNTIMES}/runtimes/${encodeURIComponent(podName)}/pause`,
+        method: 'POST',
+        token,
+        ...(body ? { body } : {}),
+    });
+};
+/**
+ * Resume a paused runtime by restoring from a checkpoint (async).
+ *
+ * Returns immediately with a 202 Accepted response.  The actual restore
+ * process runs in the background.  Use the returned `checkpoint_id` to
+ * poll for status.
+ *
+ * @param token - Authentication token
+ * @param podName - The unique pod name of the runtime to resume
+ * @param baseUrl - Base URL for the API (defaults to production Runtimes URL)
+ * @param body - Optional body with agent_spec_id and restore options
+ * @returns Promise resolving with the checkpoint ID for status tracking
+ * @throws {Error} If authentication token is missing or invalid
+ * @throws {Error} If pod name is missing or invalid
+ */
+export const resumeRuntime = async (token, podName, baseUrl = DEFAULT_SERVICE_URLS.RUNTIMES, body) => {
+    validateToken(token);
+    validateRequiredString(podName, 'Pod name');
+    return await requestDatalayerAPI({
+        url: `${baseUrl}${API_BASE_PATHS.RUNTIMES}/runtimes/${encodeURIComponent(podName)}/resume`,
+        method: 'POST',
+        token,
+        ...(body ? { body } : {}),
+    });
+};

package/lib/components/auth/Login.js

@@ -167,7 +167,7 @@ export const Login = (props) => {
                                                     ? 'Login…'
                                                     : heading
                                                         ? 'Login with Datalayer'
-                                                        : 'Login' }), _jsx(Box, { pt: 6 }), _jsx(Link, { href: "https://datalayer.app/password", target: "_blank", children: "Forgot password?" })] })] })), _jsx(Box, { children: _jsxs(Box, { display: "flex", flexDirection: "column", sx: { margin: 'auto' }, children: [showGitHubLogin &&
+                                                        : 'Login' }), _jsx(Box, { pt: 6 }), _jsx(Link, { href: "https://datalayer.ai/password", target: "_blank", children: "Forgot password?" })] })] })), _jsx(Box, { children: _jsxs(Box, { display: "flex", flexDirection: "column", sx: { margin: 'auto' }, children: [showGitHubLogin &&
                                             iamProvidersAuthorizationURL[IAMProvidersSpecs.GitHub.name] && (_jsx(Button, { leadingVisual: MarkGithubIcon, href: iamProvidersAuthorizationURL[IAMProvidersSpecs.GitHub.name], as: "a", style: { margin: '10px 0' }, children: "Login with GitHub" })), showGoogleLogin &&
                                             iamProvidersAuthorizationURL[IAMProvidersSpecs.Google.name] && (_jsx(Button, { leadingVisual: GoogleIcon, href: iamProvidersAuthorizationURL[IAMProvidersSpecs.Google.name], as: "a", style: { margin: '10px 0' }, children: "Login with Google" })), showTokenLogin && (_jsx(LoginToken, { homeRoute: homeRoute, style: { margin: '10px 0' } }))] }) })] }) })) : loadingWithToken ? (_jsx(CenteredSpinner, { message: "Checking authentication\u2026" })) : (_jsx(_Fragment, {})) })] }));
 };

package/lib/components/display/BusyDots.d.ts

@@ -0,0 +1,9 @@
+type BusyDotsProps = {
+    color?: string;
+    fontSize?: number;
+    ml?: number;
+    ariaLabel?: string;
+    intervalMs?: number;
+};
+export declare function BusyDots({ color, fontSize, ml, ariaLabel, intervalMs, }: BusyDotsProps): import("react/jsx-runtime").JSX.Element;
+export default BusyDots;

package/lib/components/display/BusyDots.js

@@ -0,0 +1,31 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { useEffect, useState } from 'react';
+import { Text } from '@primer/react';
+const DOTS = ['.', '..', '...'];
+export function BusyDots({ color = 'fg.muted', fontSize = 0, ml = 1, ariaLabel = 'In progress', intervalMs = 450, }) {
+    const [index, setIndex] = useState(0);
+    useEffect(() => {
+        const timer = window.setInterval(() => {
+            setIndex(prev => (prev + 1) % DOTS.length);
+        }, intervalMs);
+        return () => window.clearInterval(timer);
+    }, [intervalMs]);
+    return (_jsxs(Text, { as: "span", sx: {
+            ml,
+            color,
+            fontSize,
+            display: 'inline-block',
+            position: 'relative',
+            fontWeight: 'semibold',
+        }, "aria-label": ariaLabel, children: [_jsx(Text, { as: "span", sx: { visibility: 'hidden' }, children: "..." }), _jsx(Text, { as: "span", sx: {
+                    position: 'absolute',
+                    left: 0,
+                    top: 0,
+                    whiteSpace: 'nowrap',
+                }, children: DOTS[index] })] }));
+}
+export default BusyDots;

package/lib/components/display/LiveRelativeTime.d.ts

@@ -0,0 +1,10 @@
+type ILiveRelativeTimeProps = {
+    value?: Date | string | number;
+    refreshIntervalMs?: number;
+    fallback?: string;
+};
+/**
+ * Display a live-updating relative time label (e.g. "5m ago").
+ */
+export declare function LiveRelativeTime({ value, refreshIntervalMs, fallback, }: ILiveRelativeTimeProps): JSX.Element;
+export {};

package/lib/components/display/LiveRelativeTime.js

@@ -0,0 +1,21 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { useEffect, useMemo, useState } from 'react';
+import { formatRelativeTime } from '../../utils';
+/**
+ * Display a live-updating relative time label (e.g. "5m ago").
+ */
+export function LiveRelativeTime({ value, refreshIntervalMs = 1000, fallback = '—', }) {
+    const [now, setNow] = useState(() => new Date());
+    useEffect(() => {
+        const timer = window.setInterval(() => {
+            setNow(new Date());
+        }, refreshIntervalMs);
+        return () => window.clearInterval(timer);
+    }, [refreshIntervalMs]);
+    const label = useMemo(() => formatRelativeTime(value, now), [value, now]);
+    return _jsx(_Fragment, { children: label ?? fallback });
+}

package/lib/components/display/index.d.ts

@@ -4,9 +4,11 @@ export * from './CodePreview';
 export * from './DatalayerBox';
 export * from './HorizontalCenter';
 export * from './JupyterDialog';
+export * from './LiveRelativeTime';
 export * from './Markdown';
 export * from './NavLink';
 export * from './NotebookSkeleton';
+export * from './BusyDots';
 export * from './Placeholder';
 export * from './ToTopBranded';
 export * from './VisuallyHidden';

package/lib/components/display/index.js

@@ -8,9 +8,11 @@ export * from './CodePreview';
 export * from './DatalayerBox';
 export * from './HorizontalCenter';
 export * from './JupyterDialog';
+export * from './LiveRelativeTime';
 export * from './Markdown';
 export * from './NavLink';
 export * from './NotebookSkeleton';
+export * from './BusyDots';
 export * from './Placeholder';
 export * from './ToTopBranded';
 export * from './VisuallyHidden';

package/lib/components/flashes/FlashSurveys.js

@@ -30,6 +30,6 @@ export const FlashSurveys = (props) => {
         setShow(false);
         enqueueToast('Thank you for your answers.', { variant: 'success' });
     };
-    return (_jsx(_Fragment, { children: surveys && (show || surveyName) && !configuration.whiteLabel && (_jsxs(FlashClosable, { variant: "default", children: [_jsx(Box, { children: _jsx(Text, { as: "h2", children: "We'd love to know a bit more about you and your needs..." }) }), _jsx(Box, { children: _jsx(Survey2025_1, { formData: surveyName ? surveys.get(SURVEY_2025_1_NAME)?.form : undefined, onSubmit: onSubmit }) }), _jsx(Box, { mt: 3, children: _jsxs(Text, { children: ["The information you give will remain fully private, read our", ' ', _jsx(Link, { href: "https://datalayer.app/privacy", target: "_blank", children: "privacy policy" }), "."] }) })] })) }));
+    return (_jsx(_Fragment, { children: surveys && (show || surveyName) && !configuration.whiteLabel && (_jsxs(FlashClosable, { variant: "default", children: [_jsx(Box, { children: _jsx(Text, { as: "h2", children: "We'd love to know a bit more about you and your needs..." }) }), _jsx(Box, { children: _jsx(Survey2025_1, { formData: surveyName ? surveys.get(SURVEY_2025_1_NAME)?.form : undefined, onSubmit: onSubmit }) }), _jsx(Box, { mt: 3, children: _jsxs(Text, { children: ["The information you give will remain fully private, read our", ' ', _jsx(Link, { href: "https://datalayer.ai/privacy", target: "_blank", children: "privacy policy" }), "."] }) })] })) }));
 };
 export default FlashSurveys;

package/lib/components/index.d.ts

@@ -1 +1,2 @@
 export * from './auth';
+export * from './sparklines';

package/lib/components/index.js

@@ -3,3 +3,4 @@
  * Distributed under the terms of the Modified BSD License.
  */
 export * from './auth';
+export * from './sparklines';

package/lib/components/navbar/SubdomainNavBar.js

@@ -34,7 +34,7 @@ const testIds = {
         return `${this.root}-search-live-region`;
     },
 };
-function Root({ children, className, fixed = true, fullWidth = false, logoHref = 'https://datalayer.app', title, titleHref = '/', ...rest }) {
+function Root({ children, className, fixed = true, fullWidth = false, logoHref = 'https://datalayer.ai', title, titleHref = '/', ...rest }) {
     const navigate = useNavigate();
     const runStore = useRunStore();
     const { configuration } = useCoreStore();

package/lib/components/progress/ConsumptionBar.js

@@ -4,9 +4,10 @@ import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
  * Distributed under the terms of the Modified BSD License.
  */
 import { useEffect, useMemo, useState } from 'react';
+import { useInterval } from 'usehooks-ts';
 import { ProgressBar, Tooltip, Button } from '@primer/react';
 import { Box } from '@datalayer/primer-addons';
-import { useInterval } from 'usehooks-ts';
+import { getConsumptionDuration, getConsumptionProgress } from './consumption';
 const CRITICAL_LEVEL = 90;
 const WARNING_LEVEL = 75;
 /**
@@ -31,10 +32,8 @@ function formatTimeRemaining(seconds) {
  */
 export function ConsumptionBar(props) {
     const { expiredAt, startedAt, burningRate, onClick, onUpdate, refreshInterval = 2000, style, } = props;
-    const duration = useMemo(() => (expiredAt ? expiredAt - startedAt : Date.now() / 1000 - startedAt), [expiredAt, startedAt]);
-    const [progress, setProgress] = useState(expiredAt
-        ? Math.min(Math.max(0, ((Date.now() / 1000 - startedAt) / duration) * 100), 100)
-        : 100);
+    const duration = useMemo(() => getConsumptionDuration(startedAt, expiredAt), [expiredAt, startedAt]);
+    const [progress, setProgress] = useState(getConsumptionProgress(startedAt, expiredAt));
     useEffect(() => {
         if (onUpdate) {
             onUpdate(progress, duration);
@@ -42,7 +41,7 @@ export function ConsumptionBar(props) {
     }, [onUpdate, progress, duration]);
     useInterval(() => {
         if (expiredAt) {
-            setProgress(Math.min(Math.max(0, ((Date.now() / 1000 - startedAt) / duration) * 100), 100));
+            setProgress(getConsumptionProgress(startedAt, expiredAt));
         }
     }, refreshInterval);
     const bg = expiredAt
@@ -57,7 +56,7 @@ export function ConsumptionBar(props) {
     const title = duration
         ? `${formatTimeRemaining(secondsRemaining)} left - ${((progress / 100) * burntCredits).toFixed(2)} / ${burntCredits.toFixed(2)} credits`
         : `Started at ${new Date(startedAt * 1000).toISOString()} - ${burntCredits.toFixed(2)} credits consumed`;
-    return (_jsx(_Fragment, { children: _jsx(Tooltip, { text: title, direction: "w", children: _jsx(Button, { variant: "invisible", onClick: onClick, onKeyDown: onClick
+    return (_jsx(_Fragment, { children: _jsx(Tooltip, { text: title, children: _jsx(Button, { variant: "invisible", onClick: onClick, onKeyDown: onClick
                     ? event => {
                         if (event.key === 'Enter' || event.key === 'Space') {
                             onClick();

package/lib/components/progress/CreditsIndicator.js

@@ -5,8 +5,8 @@ import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
  */
 import { useState, useEffect } from 'react';
 import { Box } from '@datalayer/primer-addons';
-import { ConsumptionBar } from '../../components/progress';
-import useNavigate from '../../hooks/useNavigate';
+import { useNavigate } from '../../hooks/useNavigate';
+import { ConsumptionBar } from './ConsumptionBar';
 /**
  * Credits indicator component.
  */

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

@@ -0,0 +1,12 @@
+/**
+ * Compute the total consumption duration in seconds.
+ * When `expiredAt` is undefined, duration is elapsed time since `startedAt`.
+ */
+export declare function getConsumptionDuration(startedAt: number, expiredAt?: number, nowSeconds?: number): number;
+/**
+ * Compute credit consumption progress (0-100).
+ * Mirrors ConsumptionBar logic:
+ * - if no `expiredAt`, progress is 100
+ * - otherwise progress is elapsed / duration clamped to [0, 100]
+ */
+export declare function getConsumptionProgress(startedAt: number, expiredAt?: number, nowSeconds?: number): number;