@datalayer/core 1.1.59 → 1.1.66

package/lib/components/storage/HomeFolderDrive.d.ts

@@ -0,0 +1,71 @@
+/**
+ * The caller's Home Folders as a JupyterLab drive.
+ *
+ * One implementation of `Contents.IDrive`, so JupyterLab's file browser, the
+ * shared `ContentsBrowser` and VS Code's file system provider all read the
+ * same listing and write through the same transfer — `uploadHomeFolderFile`,
+ * verified, resumable — rather than each carrying an upload of its own.
+ *
+ * The tree is two levels of one address space: the root names the folders the
+ * caller reaches — their own, and one per organization and team — and
+ * everything below is a path inside one of them.
+ *
+ * @module components/storage/HomeFolderDrive
+ */
+import type { Contents, ServerConnection } from '@jupyterlab/services';
+import { ISignal } from '@lumino/signaling';
+export type HomeFolderDriveOptions = {
+    /** Where the Contents service is reached. */
+    contentsUrl: string;
+    /** The caller's token; the reachable folders are resolved from it. */
+    token: string;
+    /** The drive's name in JupyterLab, the prefix before `:` in a path. */
+    name?: string;
+};
+/**
+ * The Home Folders, as one JupyterLab drive.
+ *
+ * Reads come from the shared filesystem — what a sandbox wrote as well as what
+ * was uploaded. Writes go through the transfer contract: a file the browser
+ * hands over in chunks is gathered and sent whole, created, its parts
+ * checksummed, then completed; an interrupted upload resumes from the parts
+ * the service verified. Checkpoints are the immutable versions the catalog
+ * keeps of every object, so there is nothing to create here.
+ */
+export declare class HomeFolderDrive implements Contents.IDrive {
+    readonly name: string;
+    readonly serverSettings: ServerConnection.ISettings;
+    private readonly _token;
+    private readonly _base;
+    private readonly _fileChanged;
+    private readonly _pending;
+    private _isDisposed;
+    constructor(options: HomeFolderDriveOptions);
+    get fileChanged(): ISignal<Contents.IDrive, Contents.IChangedArgs>;
+    get isDisposed(): boolean;
+    dispose(): void;
+    get(localPath: string, options?: Contents.IFetchOptions): Promise<Contents.IModel>;
+    getDownloadUrl(localPath: string): Promise<string>;
+    newUntitled(options?: Contents.ICreateOptions): Promise<Contents.IModel>;
+    delete(localPath: string): Promise<void>;
+    rename(oldLocalPath: string, newLocalPath: string): Promise<Contents.IModel>;
+    /**
+     * Upload, through the same transfer the CLI and the objects view use.
+     *
+     * A file is chunked by the browser — Jupyter's protocol numbers the chunks
+     * and marks the last one `-1` — and whole by the transfer contract, so the
+     * chunks are gathered and sent when the last one arrives. One idempotency
+     * key per file and size, so the retry of an interrupted upload resumes the
+     * transfer it started rather than opening a second.
+     */
+    save(localPath: string, model?: Partial<Contents.IModel>): Promise<Contents.IModel>;
+    copy(localPath: string, toLocalDir: string): Promise<Contents.IModel>;
+    /** Every version the catalog keeps is a checkpoint already; nothing to create. */
+    createCheckpoint(localPath: string): Promise<Contents.ICheckpointModel>;
+    listCheckpoints(): Promise<Contents.ICheckpointModel[]>;
+    restoreCheckpoint(): Promise<void>;
+    deleteCheckpoint(): Promise<void>;
+    private _directory;
+    private _bytes;
+}
+export default HomeFolderDrive;

package/lib/components/storage/HomeFolderDrive.js

@@ -0,0 +1,248 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { Signal } from '@lumino/signaling';
+import { deleteHomeFolderObject, listHomeFolderFiles, readHomeFolderFile, statHomeFolderObject, uploadHomeFolderFile, } from '../../api/contents/index.js';
+import { API_BASE_PATHS } from '../../api/constants.js';
+/**
+ * A folder that has never been written to has no timestamp: it is created the
+ * first time a sandbox mounts it. Jupyter's model wants a date, and an
+ * unparseable one throws where it is rendered.
+ */
+const EPOCH = new Date(0).toISOString();
+const TEXT_EXTENSIONS = new Set([
+    'txt', 'md', 'py', 'js', 'ts', 'tsx', 'jsx', 'json', 'csv', 'tsv', 'yaml', 'yml',
+    'toml', 'html', 'css', 'xml', 'sh', 'sql', 'r', 'jl', 'rst', 'cfg', 'ini', 'log',
+]);
+const extension = (path) => (path.split('/').pop() ?? '').split('.').pop()?.toLowerCase() ?? '';
+const basename = (path) => path.split('/').filter(Boolean).pop() ?? '';
+const dirname = (path) => {
+    const parts = path.split('/').filter(Boolean);
+    parts.pop();
+    return parts.join('/');
+};
+const decodeBase64 = (value) => {
+    const binary = atob(value);
+    const bytes = new Uint8Array(binary.length);
+    for (let index = 0; index < binary.length; index += 1) {
+        bytes[index] = binary.charCodeAt(index);
+    }
+    return bytes;
+};
+const encodeBase64 = (bytes) => {
+    let binary = '';
+    for (let index = 0; index < bytes.byteLength; index += 1) {
+        binary += String.fromCharCode(bytes[index]);
+    }
+    return btoa(binary);
+};
+const joinChunks = (chunks) => {
+    const total = chunks.reduce((size, chunk) => size + chunk.byteLength, 0);
+    const joined = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+        joined.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return joined;
+};
+const fileModel = (entry) => ({
+    name: entry.name,
+    path: entry.path,
+    type: entry.isDirectory ? 'directory' : extension(entry.path) === 'ipynb' ? 'notebook' : 'file',
+    writable: true,
+    created: entry.modifiedAt || EPOCH,
+    last_modified: entry.modifiedAt || EPOCH,
+    mimetype: '',
+    content: null,
+    format: null,
+    size: entry.size,
+});
+/**
+ * The Home Folders, as one JupyterLab drive.
+ *
+ * Reads come from the shared filesystem — what a sandbox wrote as well as what
+ * was uploaded. Writes go through the transfer contract: a file the browser
+ * hands over in chunks is gathered and sent whole, created, its parts
+ * checksummed, then completed; an interrupted upload resumes from the parts
+ * the service verified. Checkpoints are the immutable versions the catalog
+ * keeps of every object, so there is nothing to create here.
+ */
+export class HomeFolderDrive {
+    name;
+    serverSettings;
+    _token;
+    _base;
+    _fileChanged = new Signal(this);
+    _pending = new Map();
+    _isDisposed = false;
+    constructor(options) {
+        this.name = options.name ?? 'home-folder';
+        this._token = options.token;
+        this._base = String(options.contentsUrl).replace(/\/$/, '');
+        // The browser reads `appUrl` in one error message and nothing else; the
+        // requests themselves carry the token explicitly.
+        this.serverSettings = {
+            baseUrl: this._base,
+            appUrl: `${this._base}${API_BASE_PATHS.CONTENTS}/sources/home-folder/`,
+            wsUrl: '',
+            token: '',
+            appendToken: false,
+            init: {},
+        };
+    }
+    get fileChanged() {
+        return this._fileChanged;
+    }
+    get isDisposed() {
+        return this._isDisposed;
+    }
+    dispose() {
+        if (this._isDisposed) {
+            return;
+        }
+        this._isDisposed = true;
+        Signal.clearData(this);
+    }
+    async get(localPath, options) {
+        const path = localPath.replace(/^\/+/, '');
+        if (path === '') {
+            return this._directory('');
+        }
+        // A folder answers the listing; a file does not, and is found in its parent.
+        try {
+            return await this._directory(path);
+        }
+        catch {
+            // Not a folder: fall through.
+        }
+        const parent = await listHomeFolderFiles(this._token, dirname(path), this._base);
+        const entry = parent.items.find(item => basename(item.path) === basename(path));
+        if (!entry || entry.isDirectory) {
+            throw new Error(`No file at ${path} in the Home Folder`);
+        }
+        const model = fileModel(entry);
+        if (options?.content === false) {
+            return model;
+        }
+        const { body } = await readHomeFolderFile(this._token, path, {}, this._base);
+        const bytes = new Uint8Array(body);
+        if (model.type === 'notebook') {
+            return { ...model, content: JSON.parse(new TextDecoder().decode(bytes)), format: 'json', mimetype: 'application/x-ipynb+json' };
+        }
+        if (options?.format === 'base64' || !TEXT_EXTENSIONS.has(extension(path))) {
+            return { ...model, content: encodeBase64(bytes), format: 'base64', mimetype: 'application/octet-stream' };
+        }
+        return { ...model, content: new TextDecoder().decode(bytes), format: 'text', mimetype: 'text/plain' };
+    }
+    getDownloadUrl(localPath) {
+        return Promise.resolve(`${this._base}${API_BASE_PATHS.CONTENTS}/sources/home-folder/files/content?path=${encodeURIComponent(localPath.replace(/^\/+/, ''))}`);
+    }
+    async newUntitled(options = {}) {
+        const type = options.type ?? 'file';
+        if (type === 'directory') {
+            throw new Error('A folder appears in the Home Folder when a file is saved into it.');
+        }
+        const parent = (options.path ?? '').replace(/^\/+|\/+$/g, '');
+        const name = type === 'notebook' ? 'Untitled.ipynb' : `untitled${options.ext ?? '.txt'}`;
+        const path = parent ? `${parent}/${name}` : name;
+        const content = type === 'notebook'
+            ? JSON.stringify({ cells: [], metadata: {}, nbformat: 4, nbformat_minor: 5 })
+            : '';
+        return this.save(path, { type, format: 'text', content });
+    }
+    async delete(localPath) {
+        const path = localPath.replace(/^\/+/, '');
+        const object = await statHomeFolderObject(this._token, path, this._base);
+        await deleteHomeFolderObject(this._token, object.uid, this._base);
+        this._fileChanged.emit({ type: 'delete', oldValue: { path }, newValue: null });
+    }
+    async rename(oldLocalPath, newLocalPath) {
+        const current = await this.get(oldLocalPath, { content: true, format: 'base64' });
+        const moved = await this.save(newLocalPath, { type: current.type, format: current.format, content: current.content });
+        await this.delete(oldLocalPath);
+        this._fileChanged.emit({ type: 'rename', oldValue: current, newValue: moved });
+        return moved;
+    }
+    /**
+     * Upload, through the same transfer the CLI and the objects view use.
+     *
+     * A file is chunked by the browser — Jupyter's protocol numbers the chunks
+     * and marks the last one `-1` — and whole by the transfer contract, so the
+     * chunks are gathered and sent when the last one arrives. One idempotency
+     * key per file and size, so the retry of an interrupted upload resumes the
+     * transfer it started rather than opening a second.
+     */
+    async save(localPath, model = {}) {
+        const path = localPath.replace(/^\/+/, '');
+        if (model.type === 'directory') {
+            throw new Error('A folder appears in the Home Folder when a file is saved into it.');
+        }
+        const bytes = this._bytes(model);
+        const chunk = model.chunk;
+        if (chunk !== undefined && chunk !== -1) {
+            this._pending.set(path, [...(this._pending.get(path) ?? []), bytes]);
+            return { ...fileModel({ name: basename(path), path, isDirectory: false, size: 0, modifiedAt: null }), chunk };
+        }
+        const content = joinChunks([...(this._pending.get(path) ?? []), bytes]);
+        this._pending.delete(path);
+        const transfer = await uploadHomeFolderFile(this._token, path, content, {
+            idempotencyKey: `home-folder-drive:${path}:${content.byteLength}`,
+            mediaType: model.mimetype || 'application/octet-stream',
+            overwrite: 'new-version',
+        }, this._base);
+        const saved = fileModel({
+            name: basename(path),
+            path,
+            isDirectory: false,
+            size: transfer.expectedSize ?? content.byteLength,
+            modifiedAt: transfer.completedAt ?? null,
+        });
+        this._fileChanged.emit({ type: 'save', oldValue: null, newValue: saved });
+        return saved;
+    }
+    async copy(localPath, toLocalDir) {
+        const current = await this.get(localPath, { content: true, format: 'base64' });
+        const target = `${toLocalDir.replace(/^\/+|\/+$/g, '')}/${basename(localPath)}`.replace(/^\//, '');
+        return this.save(target, { type: current.type, format: current.format, content: current.content });
+    }
+    /** Every version the catalog keeps is a checkpoint already; nothing to create. */
+    createCheckpoint(localPath) {
+        return Promise.resolve({ id: `latest:${localPath}`, last_modified: new Date().toISOString() });
+    }
+    listCheckpoints() {
+        return Promise.resolve([]);
+    }
+    restoreCheckpoint() {
+        return Promise.resolve();
+    }
+    deleteCheckpoint() {
+        return Promise.resolve();
+    }
+    async _directory(path) {
+        const listing = await listHomeFolderFiles(this._token, path, this._base);
+        return {
+            name: basename(path),
+            path,
+            type: 'directory',
+            writable: true,
+            created: EPOCH,
+            last_modified: EPOCH,
+            mimetype: '',
+            content: listing.items.map(fileModel),
+            format: 'json',
+            size: undefined,
+        };
+    }
+    _bytes(model) {
+        if (model.content === null || model.content === undefined) {
+            return new Uint8Array(0);
+        }
+        if (typeof model.content !== 'string') {
+            return new TextEncoder().encode(JSON.stringify(model.content, null, 1));
+        }
+        return model.format === 'base64' ? decodeBase64(model.content) : new TextEncoder().encode(model.content);
+    }
+}
+export default HomeFolderDrive;

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

@@ -1,2 +1,4 @@
 export * from './ContentsBrowser';
 export * from './ContentsItems';
+export * from './ContentsTable';
+export * from './HomeFolderDrive';

package/lib/components/storage/index.js

@@ -4,3 +4,5 @@
  */
 export * from './ContentsBrowser.js';
 export * from './ContentsItems.js';
+export * from './ContentsTable.js';
+export * from './HomeFolderDrive.js';

package/lib/components/students/StudentItemStatus.d.ts

@@ -29,5 +29,5 @@ type Props = {
     student?: IStudent;
     studentItem?: IStudentItemStatusData;
 };
-export declare const StudentItemStatus: (props: Props) => import("react/jsx-runtime").JSX.Element;
+export declare const StudentItemStatus: (props: Props) => import("react").JSX.Element;
 export default StudentItemStatus;

package/lib/components/students/StudentResultCircle.d.ts

@@ -17,5 +17,5 @@ type Props = {
  * the meaning of the green (success) / red (failure) / empty (no result yet)
  * status is discoverable on hover and focus.
  */
-export declare const StudentResultCircle: (props: Props) => import("react/jsx-runtime").JSX.Element;
+export declare const StudentResultCircle: (props: Props) => import("react").JSX.Element;
 export default StudentResultCircle;

package/lib/components/subnav/SubNav.d.ts

@@ -9,7 +9,7 @@ import '@primer/brand-primitives/lib/design-tokens/css/tokens/functional/compone
 export declare const SubNavSubMenuVariants: readonly ["dropdown", "anchor"];
 type SubMenuVariants = (typeof SubNavSubMenuVariants)[number];
 type SubNavContextType = {
-    portalRef: RefObject<HTMLDivElement>;
+    portalRef: RefObject<HTMLDivElement | null>;
 };
 export declare const useSubNavContext: () => SubNavContextType;
 export type SubNavProps = {
@@ -34,7 +34,7 @@ type SubNavLinkProps = {
 type SubMenuProps = {
     variant?: SubMenuVariants;
 } & React.HTMLAttributes<HTMLUListElement> & BaseProps<HTMLUListElement>;
-declare function SubMenu({ children, className, variant, ...props }: SubMenuProps): import("react/jsx-runtime").JSX.Element;
+declare function SubMenu({ children, className, variant, ...props }: SubMenuProps): React.JSX.Element;
 type SubNavActionProps = {
     /**
      * Required path or location for the action button to link to.
@@ -49,7 +49,7 @@ type SubNavActionProps = {
      */
     variant?: (typeof ButtonVariants)[number];
 } & Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, 'href'>;
-declare function _SubNavAction({ children, href, variant, size, ...rest }: SubNavActionProps): import("react/jsx-runtime").JSX.Element;
+declare function _SubNavAction({ children, href, variant, size, ...rest }: SubNavActionProps): React.JSX.Element;
 /**
  * Use SubNav to display a secondary navigation beneath a primary header.
  * @see https://primer.style/brand/components/SubNav
@@ -65,9 +65,9 @@ export declare const SubNav: React.NamedExoticComponent<{
 } & BaseProps<HTMLElement> & {
     children?: ReactNode | undefined;
 }> & {
-    readonly type: ({ id, children, className, "data-testid": testId, fullWidth, hasShadow, }: SubNavProps) => import("react/jsx-runtime").JSX.Element;
+    readonly type: ({ id, children, className, "data-testid": testId, fullWidth, hasShadow, }: SubNavProps) => React.JSX.Element;
 } & {
-    Heading: ({ href, children, className, "data-testid": testID, ...props }: SubNavHeadingProps) => import("react/jsx-runtime").JSX.Element;
+    Heading: ({ href, children, className, "data-testid": testID, ...props }: SubNavHeadingProps) => React.JSX.Element;
     Link: React.ForwardRefExoticComponent<Omit<SubNavLinkProps, "ref"> & React.RefAttributes<HTMLAnchorElement | HTMLDivElement>>;
     Action: typeof _SubNavAction;
     SubMenu: typeof SubMenu;

package/lib/components/subnav/SubNav.js

@@ -106,7 +106,8 @@ const _SubNavRoot = memo(({ id, children, className, 'data-testid': testId, full
     useEffect(() => {
         // check if there is an anchored nav in the SubNav.SubMenu child
         const hasAnchorVariant = childrenArr.some(child => {
-            if (isValidElement(child) && child.type === SubNavLink) {
+            if (isValidElement(child) &&
+                child.type === SubNavLink) {
                 const [, subMenu] = child.props.children;
                 if (subMenu?.props?.variant === 'anchor') {
                     return true;
@@ -144,12 +145,15 @@ const _SubNavRoot = memo(({ id, children, className, 'data-testid': testId, full
         }
         return acc;
     }, { heading: undefined, links: [], action: undefined });
-    const activeLinklabel = typeof activeLink?.props.children === 'string'
-        ? activeLink.props.children
-        : activeLink?.props.children[0];
+    const activeLinkChildren = activeLink?.props.children;
+    const activeLinklabel = typeof activeLinkChildren === 'string'
+        ? activeLinkChildren
+        : activeLinkChildren?.[0];
     // needed to prevent rendering of anchor subnav inside the narrow <Button variant="invisible"> element
-    const MaybeSubNav = activeLink?.props.children?.[1]?.props?.variant === 'anchor' &&
-        activeLink.props.children?.[1];
+    const activeLinkSubMenu = typeof activeLinkChildren === 'string'
+        ? undefined
+        : activeLinkChildren?.[1];
+    const MaybeSubNav = activeLinkSubMenu?.props?.variant === 'anchor' && activeLinkSubMenu;
     return (_jsx("div", { className: clsx(styles['SubNav__container'], hasAnchoredNav && styles['SubNav__container--with-anchor-nav']), children: _jsx(SubNavProvider, { children: _jsx("nav", { ref: navRef, id: id, className: clsx(styles.SubNav, isOpenAtNarrow && styles['SubNav--open'], hasShadow && styles['SubNav--has-shadow'], fullWidth && styles['SubNav--full-width'], className), "data-testid": testId || testIds.root, children: _jsxs("div", { ref: rootRef, className: styles['SubNav--header-container-outer'], children: [_jsxs("div", { className: styles['SubNav__header-container'], children: [HeadingChild && (_jsx("div", { className: styles['SubNav__heading-container'], children: HeadingChild })), !isLarge && (_jsxs("button", { className: clsx(styles['SubNav__overlay-toggle'], isOpenAtNarrow && styles['SubNav__overlay-toggle--open']), "data-testid": testIds.button, onClick: isOpenAtNarrow ? closeMenuCallback : handleMenuToggle, "aria-expanded": isOpenAtNarrow ? 'true' : 'false', "aria-controls": idForLinkContainer, children: [activeLinklabel && (_jsxs("span", { className: "visually-hidden", children: ["Navigation menu. Current page:", ' '] })), _jsxs("span", { className: clsx(styles['SubNav__overlay-toggle-content'], !activeLinklabel &&
                                                 styles['SubNav__overlay-toggle-content--end']), children: [activeLinklabel && (_jsx(Text, { as: "span", size: "200", children: activeLinklabel })), isOpenAtNarrow ? (_jsx(ChevronUpIcon, { className: styles['SubNav__overlay-toggle-icon'], size: 24 })) : (_jsx(ChevronDownIcon, { className: styles['SubNav__overlay-toggle-icon'], size: 24 }))] })] })), MaybeSubNav && MaybeSubNav] }), LinkChildren.length && (_jsxs("ul", { ref: overlayRef, id: idForLinkContainer, className: clsx(styles['SubNav__links-overlay'], isOpenAtNarrow && styles['SubNav__links-overlay--open']), "data-testid": testIds.overlay, children: [ActionChild ? (_jsx("li", { className: styles['SubNav__action-container'], children: ActionChild })) : (_jsx("li", { className: styles['SubNav__action-container'] })), LinkChildren, _jsx(ButtonGroup, { buttonSize: "small", children: _jsx(Button, { href: "#", onClick: e => {
                                             window.location.assign('https://datalayer.ai');
@@ -251,9 +255,7 @@ function SubMenu({ children, className, variant = 'dropdown', ...props }) {
                     if (isValidElement(child)) {
                         return React.cloneElement(child, {
                             onClick: e => {
-                                if (child.props.onClick) {
-                                    child.props.onClick(e);
-                                }
+                                child.props.onClick?.(e);
                             },
                         });
                     }

package/lib/components/tables/DataTable.d.ts

@@ -1,5 +1,5 @@
 type IDataTableProps = {
     data: Array<any>;
 };
-export declare const DataTable: (props: IDataTableProps) => import("react/jsx-runtime").JSX.Element;
+export declare const DataTable: (props: IDataTableProps) => import("react").JSX.Element;
 export default DataTable;

package/lib/components/text-reveal/TextRevealAnimation.d.ts

@@ -1,6 +1,6 @@
 import React from 'react';
 import { BaseProps } from '@datalayer/primer-addons';
 export type TextRevealAnimationProps = BaseProps<HTMLSpanElement> & Omit<React.HTMLAttributes<HTMLSpanElement>, 'children'> & {
-    children: React.ReactChild;
+    children: React.ReactElement | string | number;
 };
-export declare function TextRevealAnimation({ children, ...rest }: TextRevealAnimationProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function TextRevealAnimation({ children, ...rest }: TextRevealAnimationProps): React.JSX.Element | null;

package/lib/components/text-reveal/useTextRevealAnimationLines.d.ts

@@ -1,4 +1,4 @@
 export declare const useTextRevealAnimationLines: (text?: string) => {
-    ref: import("react").RefObject<HTMLElement>;
+    ref: import("react").RefObject<HTMLElement | null>;
     lines: string[] | undefined;
 };

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

@@ -1,3 +1,4 @@
+import type { JSX } from 'react';
 type ILiveRelativeTimeProps = {
     value?: Date | string | number;
     refreshIntervalMs?: number;

package/lib/components/time/LiveRelativeTime.js

@@ -1,12 +1,4 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-/*
- * Copyright (c) 2023-2025 Datalayer, Inc.
- * Distributed under the terms of the Modified BSD License.
- */
-/*
- * Copyright (c) 2023-2026 Datalayer, Inc.
- * Distributed under the terms of the Modified BSD License.
- */
 import { useEffect, useMemo, useState } from 'react';
 import { Tooltip } from '@primer/react';
 import { formatDateTimeDetails, formatRelativeTime } from '../../utils/index.js';

package/lib/components/time/index.js

@@ -2,8 +2,4 @@
  * Copyright (c) 2023-2025 Datalayer, Inc.
  * Distributed under the terms of the Modified BSD License.
  */
-/*
- * Copyright (c) 2023-2026 Datalayer, Inc.
- * Distributed under the terms of the Modified BSD License.
- */
 export * from './LiveRelativeTime.js';

package/lib/components/timeline/Timeline.d.ts

@@ -17,4 +17,4 @@ export type TimelineProps = {
  * The first item is rendered on the left. Pass items in the desired order
  * (for example: newest to oldest).
  */
-export declare const Timeline: ({ items, renderTimestamp }: TimelineProps) => import("react/jsx-runtime").JSX.Element | null;
+export declare const Timeline: ({ items, renderTimestamp }: TimelineProps) => import("react").JSX.Element | null;

package/lib/components/timeline/index.js

@@ -2,8 +2,4 @@
  * Copyright (c) 2023-2025 Datalayer, Inc.
  * Distributed under the terms of the Modified BSD License.
  */
-/*
- * Copyright (c) 2023-2026 Datalayer, Inc.
- * Distributed under the terms of the Modified BSD License.
- */
 export * from './Timeline.js';

package/lib/components/users/PeerIndicator.d.ts

@@ -1,3 +1,4 @@
+import type { JSX } from 'react';
 import type { Awareness } from 'y-protocols/awareness';
 /**
  * PeersIndicator properties

package/lib/components/users/PeerIndicator.js

@@ -1,8 +1,4 @@
 import { jsx as _jsx } 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 { AvatarStack } from '@primer/react';
 import { getRelativeTime } from '../../utils/index.js';

package/lib/config/Configuration.d.ts

@@ -41,6 +41,10 @@ export type IDatalayerCoreConfig = {
      * IAM API URL.
      */
     iamUrl: string;
+    /**
+     * Contents API URL.
+     */
+    contentsUrl: string;
     /**
      * Manager API URL.
      */
@@ -76,25 +80,13 @@ export type IDatalayerCoreConfig = {
     /**
      * OTEL (OpenTelemetry) API URL.
      *
-     * This is the endpoint runtimes/agents export telemetry to. In the browser
-     * it is also the default endpoint used to *consume* (query) telemetry, unless
-     * {@link otelInUrl} is provided.
+     * Both directions: the endpoint runtimes and agents export telemetry to, and
+     * the endpoint the browser reads it back from. A separate consume URL existed
+     * so a local UI could read from a remote service while exporting elsewhere;
+     * pointing this at that service does the same thing without two fields that
+     * can disagree.
      */
     otelUrl: string;
-    /**
-     * OTEL (OpenTelemetry) *consume* (read/query) API URL override.
-     *
-     * When set, the UI reads telemetry (metrics, traces, logs) from this URL
-     * instead of {@link otelUrl}. When empty/undefined, {@link otelUrl} is used.
-     *
-     * Primary use case: local development. When runtimes run in the cloud and
-     * export their telemetry to the production OTEL service, a local UI must fetch
-     * telemetry from production rather than from the local OTEL endpoint. Set this
-     * to e.g. `https://prod1.datalayer.run` while `otelUrl` stays local.
-     *
-     * Fed by the `DATALAYER_OTEL_IN_URL` environment variable at build/deploy time.
-     */
-    otelInUrl?: string;
     /**
      * Growth API URL.
      */
@@ -184,6 +176,12 @@ export declare class DatalayerConfiguration {
  * what each of them falls back to.
  */
 export declare const DEFAULT_DATALAYER_SERVICE_URL = "https://prod1.datalayer.run";
+/**
+ * Where the Contents service lives when nothing says otherwise.
+ *
+ * Not the generic default: Contents runs on the runtimes plane, where the NFS that backs the Home Folder and Volumes lives.
+ */
+export declare const DEFAULT_DATALAYER_CONTENTS_URL = "https://r1.datalayer.run";
 export declare const DEFAULT_DATALAYER_CONFIG: Partial<IDatalayerCoreConfig>;
 /**
  * Type guard to check if a config object is a valid IDatalayerConfig

package/lib/config/Configuration.js

@@ -32,8 +32,15 @@ export class DatalayerConfiguration {
  * what each of them falls back to.
  */
 export const DEFAULT_DATALAYER_SERVICE_URL = 'https://prod1.datalayer.run';
+/**
+ * Where the Contents service lives when nothing says otherwise.
+ *
+ * Not the generic default: Contents runs on the runtimes plane, where the NFS that backs the Home Folder and Volumes lives.
+ */
+export const DEFAULT_DATALAYER_CONTENTS_URL = 'https://r1.datalayer.run';
 export const DEFAULT_DATALAYER_CONFIG = {
     iamUrl: DEFAULT_DATALAYER_SERVICE_URL,
+    contentsUrl: DEFAULT_DATALAYER_CONTENTS_URL,
     credits: 100,
     cpuEnvironment: 'ai-agents-env',
     gpuEnvironment: 'ai-env',

package/lib/hooks/index.d.ts

@@ -3,6 +3,7 @@ export * from './useBackdrop';
 export * from './useBackdropJupyterLab';
 export * from './useCache';
 export * from './useContainsFocus';
+export * from './useContents';
 export * from './useDatalayer';
 export * from './useError';
 export * from './useExternalScript';
@@ -16,6 +17,7 @@ export * from './useKeyboardShortcuts';
 export * from './useKeyboardEscape';
 export * from './useLocation';
 export * from './useLocationHandles';
+export * from './useMcp';
 export * from './useNavigate';
 export * from './useParams';
 export * from './useOnClickOutside';

package/lib/hooks/index.js

@@ -7,6 +7,7 @@ export * from './useBackdrop.js';
 export * from './useBackdropJupyterLab.js';
 export * from './useCache.js';
 export * from './useContainsFocus.js';
+export * from './useContents.js';
 export * from './useDatalayer.js';
 // export * from "./useCellOutputshot.js"; // Do not export html2canvas
 export * from './useError.js';
@@ -21,6 +22,7 @@ export * from './useKeyboardShortcuts.js';
 export * from './useKeyboardEscape.js';
 export * from './useLocation.js';
 export * from './useLocationHandles.js';
+export * from './useMcp.js';
 export * from './useNavigate.js';
 export * from './useParams.js';
 export * from './useOnClickOutside.js';

package/lib/hooks/layouts/LayoutBackdrop.d.ts

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

package/lib/hooks/layouts/LayoutScreencapture.d.ts

@@ -1,3 +1,3 @@
 import '../../../style/screencapture/index.css';
-export declare const LayoutScreencapture: () => import("react/jsx-runtime").JSX.Element;
+export declare const LayoutScreencapture: () => import("react").JSX.Element;
 export default LayoutScreencapture;

package/lib/hooks/useBackdrop.d.ts

@@ -16,7 +16,7 @@ export type IBackdropProviderProps = {
     disableDarken?: boolean;
     backdropSurface?: any;
 };
-export declare function BackdropProvider({ children, zIndex, disableDarken, backdropSurface, }: IBackdropProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function BackdropProvider({ children, zIndex, disableDarken, backdropSurface, }: IBackdropProviderProps): import("react").JSX.Element;
 export declare namespace BackdropProvider {
     var propTypes: {
         children: PropTypes.Requireable<NonNullable<PropTypes.ReactNodeLike>>;