@myst-theme/jupyter 0.3.2 → 0.3.4

package/dist/esm/execute/hooks.d.ts

@@ -0,0 +1,62 @@
+import React from 'react';
+import type { IdOrKey } from './types';
+import type { IThebeCell } from 'thebe-core';
+import { SourceFileKind } from 'myst-common';
+export declare function useExecutionScope({ clearOutputsOnExecute, }?: {
+    clearOutputsOnExecute?: boolean;
+}): {
+    ready: boolean;
+    start: (slug: string) => void;
+    clearAll: (pageSlug: string) => void;
+    resetAll: (pageSlug: string) => void;
+    execute: (slug: string) => void;
+    slug: string;
+    state: import("./types").ExecuteScopeState;
+    dispatch: React.Dispatch<import("./actions").ExecuteScopeAction>;
+    idkmap: import("./types").IdKeyMap;
+};
+/**
+ * useNotebookExecution a hook to govern notebook execution in the context of a single
+ * cell embedded in an article
+ *
+ */
+export declare function useNotebookExecution(id: IdOrKey, clearOutputsOnExecute?: boolean): {
+    ready: boolean;
+    start: () => void;
+    clear: () => void;
+    reset: () => void;
+    execute: () => void;
+    cellIsExecuting: boolean;
+    notebookIsExecuting: boolean;
+    notebookIsResetting: boolean;
+    notebookIsBusy: boolean;
+    executionCount: number | null | undefined;
+    slug: string;
+    state: import("./types").ExecuteScopeState;
+    dispatch: React.Dispatch<import("./actions").ExecuteScopeAction>;
+    idkmap: import("./types").IdKeyMap;
+};
+/**
+ * useCellExecution a hook to govern the execute status and actions for a single cell
+ *
+ * @param id
+ * @returns
+ */
+export declare function useCellExecution(id: IdOrKey): {
+    kind: SourceFileKind;
+    ready: boolean;
+    execute: () => void;
+    clear: () => void;
+    cellIsExecuting: boolean;
+    notebookIsExecuting: boolean;
+    notebookIsResetting: boolean;
+    notebookIsBusy: boolean;
+    cell: IThebeCell | undefined;
+};
+export declare function useIsAComputableCell(id: IdOrKey): {
+    slug: string;
+    computable: boolean;
+    ready: boolean;
+};
+export declare function useReadyToExecute(): boolean;
+//# sourceMappingURL=hooks.d.ts.map

package/dist/esm/execute/hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../../../src/execute/hooks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAsB,MAAM,OAAO,CAAC;AAC3C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAEvC,OAAO,KAAK,EAAE,UAAU,EAA0C,MAAM,YAAY,CAAC;AAGrF,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAE7C,wBAAgB,iBAAiB,CAAC,EAChC,qBAA6B,GAC9B,GAAE;IAAE,qBAAqB,CAAC,EAAE,OAAO,CAAA;CAAO;;kBAUR,MAAM;yBAsD1B,MAAM;yBAYN,MAAM;oBAxDI,MAAM;;;;;EAgF9B;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,OAAO,EAAE,qBAAqB,UAAQ;;;;;;;;;;;;;;;EA4G9E;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,OAAO;;;;;;;;;;EAiE3C;AAED,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,OAAO;;;;EAc/C;AAED,wBAAgB,iBAAiB,YAOhC"}

package/dist/esm/execute/hooks.js

@@ -0,0 +1,277 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import React, { useCallback } from 'react';
+import { ExecuteScopeContext } from './provider';
+import { useBusyScope } from './busy';
+import { findErrors, useThebeConfig } from 'thebe-react';
+import { SourceFileKind } from 'myst-common';
+export function useExecutionScope({ clearOutputsOnExecute = false, } = {}) {
+    var _a;
+    const context = React.useContext(ExecuteScopeContext);
+    const { config } = useThebeConfig();
+    const busy = useBusyScope();
+    if (context === undefined) {
+        throw new Error('useExecuteScope must be used within a ExecuteScopeProvider');
+    }
+    const { state, dispatch } = context;
+    const start = useCallback((slug) => {
+        console.debug(`Jupyter: Starting ${slug}`);
+        dispatch({
+            type: 'REQUEST_BUILD',
+            payload: {
+                slug,
+            },
+        });
+    }, []);
+    const execute = (slug) => {
+        // set busy
+        Object.entries(state.pages[slug].scopes).forEach(([notebookSlug, { notebook }]) => {
+            busy.setNotebook(slug, notebookSlug, notebook.cells.map((c) => c.id), 'execute');
+        });
+        if (clearOutputsOnExecute) {
+            // clear all notebook cell outputs
+            Object.values(state.pages[slug].scopes).forEach(({ notebook }) => {
+                notebook.clear();
+            });
+        }
+        // let busy state update prior to launching execute
+        setTimeout(() => __awaiter(this, void 0, void 0, function* () {
+            const handler = (_, data) => {
+                var _a, _b;
+                if (data.subject === 'cell' && data.status === 'idle') {
+                    const notebookSlug = (_a = data.object.notebookId) !== null && _a !== void 0 ? _a : 'unknown';
+                    busy.clearCell(slug, notebookSlug, (_b = data.id) !== null && _b !== void 0 ? _b : 'unknown', 'execute');
+                }
+            };
+            config === null || config === void 0 ? void 0 : config.events.on('status', handler);
+            // execute all cells on all notebooks
+            yield Promise.all(Object.entries(state.pages[slug].scopes).map(([, { notebook }]) => __awaiter(this, void 0, void 0, function* () {
+                const execReturns = yield notebook.executeAll(true);
+                const errs = findErrors(execReturns);
+                if (errs != null)
+                    console.error('errors', errs);
+            })));
+            config === null || config === void 0 ? void 0 : config.events.off('status', handler);
+        }), 100);
+    };
+    /**
+     * clearAll clears all cells in all notebooks for a given rendering
+     *
+     */
+    const clearAll = useCallback((pageSlug) => {
+        Object.entries(state.pages[pageSlug].scopes).forEach(([, { notebook }]) => {
+            notebook.clear();
+        });
+    }, [state]);
+    /**
+     * resetAll resets all cells in all notebooks for a given rendering
+     */
+    const resetAll = useCallback((pageSlug) => {
+        Object.entries(state.pages[pageSlug].scopes).forEach(([notebookSlug, { notebook, session }]) => {
+            busy.setNotebook(pageSlug, notebookSlug, notebook.cells.map((c) => c.id), 'reset');
+            setTimeout(() => {
+                var _a;
+                notebook.reset();
+                (_a = session === null || session === void 0 ? void 0 : session.kernel) === null || _a === void 0 ? void 0 : _a.restart().finally(() => {
+                    busy.clearNotebook(pageSlug, notebookSlug, 'reset');
+                });
+            }, 300);
+        });
+    }, [state]);
+    const ready = (_a = context.state.pages[context.slug]) === null || _a === void 0 ? void 0 : _a.ready;
+    return Object.assign(Object.assign({}, context), { ready, start, clearAll, resetAll, execute });
+}
+/**
+ * useNotebookExecution a hook to govern notebook execution in the context of a single
+ * cell embedded in an article
+ *
+ */
+export function useNotebookExecution(id, clearOutputsOnExecute = false) {
+    var _a, _b;
+    const context = React.useContext(ExecuteScopeContext);
+    const { config } = useThebeConfig();
+    const busy = useBusyScope();
+    if (context === undefined) {
+        throw new Error('useExecuteScope must be used within a ExecuteScopeProvider');
+    }
+    const { state, dispatch, idkmap } = context;
+    const target = (_a = idkmap[id]) !== null && _a !== void 0 ? _a : {};
+    const { pageSlug, notebookSlug, cellId } = target;
+    // TODO consider extending this to start only the notebook requested, currently this will
+    // execute all connected notebooks
+    const start = useCallback(() => {
+        dispatch({
+            type: 'REQUEST_BUILD',
+            payload: {
+                slug: context.slug,
+            },
+        });
+    }, [target]);
+    let cell;
+    let notebook;
+    if (target && state.pages[pageSlug]) {
+        notebook = state.pages[pageSlug].scopes[notebookSlug].notebook;
+        if (!notebook)
+            console.error('no notebook for', { pageSlug, notebookSlug, cellId });
+        cell = notebook === null || notebook === void 0 ? void 0 : notebook.getCellById(cellId);
+        if (!cell)
+            console.error('no cell found', { pageSlug, notebookSlug, cellId });
+    }
+    const execute = () => {
+        var _a, _b;
+        const nb = (_b = (_a = state.pages[pageSlug]) === null || _a === void 0 ? void 0 : _a.scopes[notebookSlug]) === null || _b === void 0 ? void 0 : _b.notebook;
+        // set busy
+        busy.setNotebook(pageSlug, notebookSlug, nb.cells.map((c) => c.id), 'execute');
+        if (clearOutputsOnExecute)
+            nb.clear();
+        // let busy state update prior to launching execute
+        setTimeout(() => __awaiter(this, void 0, void 0, function* () {
+            const handler = (_, data) => {
+                var _a;
+                if (data.subject === 'cell' && data.status === 'idle') {
+                    busy.clearCell(pageSlug, notebookSlug, (_a = data.id) !== null && _a !== void 0 ? _a : 'unknown', 'execute');
+                }
+            };
+            config === null || config === void 0 ? void 0 : config.events.on('status', handler);
+            // execute all cells on the notebooks
+            const execReturns = yield nb.executeAll(true);
+            const errs = findErrors(execReturns);
+            if (errs != null)
+                console.error('errors', errs); // TODO: handle errors
+            config === null || config === void 0 ? void 0 : config.events.off('status', handler);
+        }), 100);
+    };
+    /**
+     * clearAll clears all cells in all notebooks for a given rendering
+     *
+     */
+    const clear = useCallback(() => {
+        var _a, _b;
+        const nb = (_b = (_a = state.pages[pageSlug]) === null || _a === void 0 ? void 0 : _a.scopes[notebookSlug]) === null || _b === void 0 ? void 0 : _b.notebook;
+        nb.clear();
+    }, [state]);
+    /**
+     * resetAll resets all cells in all notebooks for a given rendering
+     */
+    const reset = useCallback(() => {
+        var _a, _b;
+        const { notebook: nb, session } = (_b = (_a = state.pages[pageSlug]) === null || _a === void 0 ? void 0 : _a.scopes[notebookSlug]) !== null && _b !== void 0 ? _b : {};
+        busy.setNotebook(pageSlug, notebookSlug, nb.cells.map((c) => c.id), 'reset');
+        setTimeout(() => {
+            var _a;
+            nb.reset();
+            (_a = session === null || session === void 0 ? void 0 : session.kernel) === null || _a === void 0 ? void 0 : _a.restart().finally(() => {
+                busy.clearNotebook(pageSlug, notebookSlug, 'reset');
+            });
+        }, 300);
+    }, [state]);
+    const ready = (_b = context.state.pages[context.slug]) === null || _b === void 0 ? void 0 : _b.ready;
+    const notebookIsExecuting = busy.notebook(pageSlug, notebookSlug, 'execute');
+    const notebookIsResetting = busy.notebook(pageSlug, notebookSlug, 'reset');
+    const notebookIsBusy = notebookIsExecuting || notebookIsResetting;
+    return Object.assign(Object.assign({}, context), { ready,
+        start,
+        clear,
+        reset,
+        execute, cellIsExecuting: cell ? busy.cell(pageSlug, notebookSlug, cell === null || cell === void 0 ? void 0 : cell.id, 'execute') : false, notebookIsExecuting,
+        notebookIsResetting,
+        notebookIsBusy, executionCount: cell === null || cell === void 0 ? void 0 : cell.executionCount });
+}
+/**
+ * useCellExecution a hook to govern the execute status and actions for a single cell
+ *
+ * @param id
+ * @returns
+ */
+export function useCellExecution(id) {
+    var _a, _b, _c, _d;
+    const busy = useBusyScope();
+    const context = React.useContext(ExecuteScopeContext);
+    if (context === undefined) {
+        throw new Error('useExecuteScope must be used within a ExecuteScopeProvider');
+    }
+    const { state, idkmap } = context;
+    const target = (_a = idkmap[id]) !== null && _a !== void 0 ? _a : {};
+    const { pageSlug, notebookSlug, cellId } = target;
+    let cell;
+    let notebook;
+    if (target && state.pages[pageSlug]) {
+        notebook = state.pages[pageSlug].scopes[notebookSlug].notebook;
+        if (!notebook)
+            console.error('no notebook for', { pageSlug, notebookSlug, cellId });
+        cell = notebook === null || notebook === void 0 ? void 0 : notebook.getCellById(cellId);
+        if (!cell)
+            console.error('no cell found', { pageSlug, notebookSlug, cellId });
+    }
+    const ready = (_b = context.state.pages[context.slug]) === null || _b === void 0 ? void 0 : _b.ready;
+    const kind = (_d = (_c = context.state.pages[context.slug]) === null || _c === void 0 ? void 0 : _c.kind) !== null && _d !== void 0 ? _d : SourceFileKind.Article;
+    const execute = useCallback(() => {
+        if (!cell) {
+            console.error('no cell found on execute', { pageSlug, notebookSlug, cellId });
+            return;
+        }
+        // set busy
+        busy.setCell(pageSlug, notebookSlug, cell.id, 'execute');
+        cell.clear();
+        // let busy state update prior to launching execute
+        setTimeout(() => {
+            if (!cell)
+                throw new Error('no cell found on execute');
+            cell.execute().then(() => {
+                if (!cell)
+                    throw new Error('no cell found after execute');
+                busy.clearCell(pageSlug, notebookSlug, cell === null || cell === void 0 ? void 0 : cell.id, 'execute');
+            });
+        }, 100);
+    }, [state, cell]);
+    const clear = useCallback(() => {
+        if (!cell) {
+            console.error('no cell found on clear', { pageSlug, notebookSlug, cellId });
+            return;
+        }
+        cell.clear();
+    }, [state, cell]);
+    const notebookIsExecuting = busy.notebook(pageSlug, notebookSlug, 'execute');
+    const notebookIsResetting = busy.notebook(pageSlug, notebookSlug, 'reset');
+    const notebookIsBusy = notebookIsExecuting || notebookIsResetting;
+    return {
+        kind,
+        ready,
+        execute,
+        clear,
+        cellIsExecuting: cell ? busy.cell(pageSlug, notebookSlug, cell === null || cell === void 0 ? void 0 : cell.id, 'execute') : false,
+        notebookIsExecuting,
+        notebookIsResetting,
+        notebookIsBusy,
+        cell,
+    };
+}
+export function useIsAComputableCell(id) {
+    var _a, _b, _c;
+    const context = React.useContext(ExecuteScopeContext);
+    if (context === undefined) {
+        throw new Error('useExecuteScope must be used within a ExecuteScopeProvider');
+    }
+    const { idkmap } = context;
+    const target = (_a = idkmap[id]) !== null && _a !== void 0 ? _a : {};
+    return {
+        slug: context.slug,
+        computable: !!target,
+        ready: (_c = (_b = context.state.pages[context.slug]) === null || _b === void 0 ? void 0 : _b.ready) !== null && _c !== void 0 ? _c : false,
+    };
+}
+export function useReadyToExecute() {
+    var _a, _b;
+    const context = React.useContext(ExecuteScopeContext);
+    if (context === undefined) {
+        throw new Error('useExecuteScope must be used within a ExecuteScopeProvider');
+    }
+    return (_b = (_a = context.state.pages[context.slug]) === null || _a === void 0 ? void 0 : _a.ready) !== null && _b !== void 0 ? _b : false;
+}

package/dist/esm/execute/index.d.ts

@@ -0,0 +1,7 @@
+export * from './hooks';
+export * from './actions';
+export * from './provider';
+export * from './selectors';
+export * from './types';
+export * from './busy';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/execute/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/execute/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC;AACxB,cAAc,QAAQ,CAAC"}

package/dist/esm/execute/index.js

@@ -0,0 +1,6 @@
+export * from './hooks';
+export * from './actions';
+export * from './provider';
+export * from './selectors';
+export * from './types';
+export * from './busy';

package/dist/esm/execute/leaf.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="react" />
+import type { ExecuteScopeAction } from './actions';
+import type { IdKeyMap, ExecuteScopeState } from './types';
+export declare function MdastFetcher({ slug, url, dispatch, }: {
+    slug: string;
+    url: string;
+    dispatch: React.Dispatch<ExecuteScopeAction>;
+}): import("react/jsx-runtime").JSX.Element | null;
+export declare function NotebookBuilder({ pageSlug, notebookSlug, idkmap, state, dispatch, }: {
+    pageSlug: string;
+    notebookSlug: string;
+    idkmap: IdKeyMap;
+    state: ExecuteScopeState;
+    dispatch: React.Dispatch<ExecuteScopeAction>;
+}): null;
+export declare function SessionStarter({ pageSlug, notebookSlug, state, dispatch, }: {
+    pageSlug: string;
+    notebookSlug: string;
+    state: ExecuteScopeState;
+    dispatch: React.Dispatch<ExecuteScopeAction>;
+}): null;
+export declare function ServerMonitor({ state, dispatch, }: {
+    state: ExecuteScopeState;
+    dispatch: React.Dispatch<ExecuteScopeAction>;
+}): null;
+//# sourceMappingURL=leaf.d.ts.map

package/dist/esm/execute/leaf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"leaf.d.ts","sourceRoot":"","sources":["../../../src/execute/leaf.tsx"],"names":[],"mappings":";AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AACpD,OAAO,KAAK,EAAE,QAAQ,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAO3D,wBAAgB,YAAY,CAAC,EAC3B,IAAI,EACJ,GAAG,EACH,QAAQ,GACT,EAAE;IACD,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC,kBAAkB,CAAC,CAAC;CAC9C,kDAkBA;AAED,wBAAgB,eAAe,CAAC,EAC9B,QAAQ,EACR,YAAY,EACZ,MAAM,EACN,KAAK,EACL,QAAQ,GACT,EAAE;IACD,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,QAAQ,CAAC;IACjB,KAAK,EAAE,iBAAiB,CAAC;IACzB,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC,kBAAkB,CAAC,CAAC;CAC9C,QA8CA;AAED,wBAAgB,cAAc,CAAC,EAC7B,QAAQ,EACR,YAAY,EACZ,KAAK,EACL,QAAQ,GACT,EAAE;IACD,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,iBAAiB,CAAC;IACzB,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC,kBAAkB,CAAC,CAAC;CAC9C,QAoEA;AAED,wBAAgB,aAAa,CAAC,EAC5B,KAAK,EACL,QAAQ,GACT,EAAE;IACD,KAAK,EAAE,iBAAiB,CAAC;IACzB,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC,kBAAkB,CAAC,CAAC;CAC9C,QA4BA"}

package/dist/esm/execute/leaf.js

@@ -0,0 +1,147 @@
+import { jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useRef } from 'react';
+import { useThebeLoader, useThebeConfig, useThebeServer } from 'thebe-react';
+import { notebookFromMdast } from './utils';
+import { selectAreAllNotebookScopesBuilt, selectAreAllSessionsStarted } from './selectors';
+import { useFetchMdast } from 'myst-to-react';
+export function MdastFetcher({ slug, url, dispatch, }) {
+    const { data, error } = useFetchMdast({ remote: true, dataUrl: `${url}.json` });
+    useEffect(() => {
+        if (!data)
+            return;
+        dispatch({ type: 'ADD_MDAST', payload: { slug, mdast: data.mdast } });
+    }, [data]);
+    if (error) {
+        return (_jsxs("div", { children: ["error: ", slug, error.message] }));
+    }
+    return null;
+}
+export function NotebookBuilder({ pageSlug, notebookSlug, idkmap, state, dispatch, }) {
+    var _a;
+    const { core } = useThebeLoader();
+    const { config } = useThebeConfig();
+    const lock = useRef(false); // TODO can be removed if we solve double render from provider
+    const scopeHasNotebook = !!((_a = state.pages[pageSlug]) === null || _a === void 0 ? void 0 : _a.scopes[notebookSlug]);
+    useEffect(() => {
+        var _a;
+        if (!core || !config || scopeHasNotebook || lock.current)
+            return;
+        lock.current = true;
+        console.debug(`Jupyter: NotebookBuilder - ${notebookSlug} being added to scope ${pageSlug}`);
+        const rendermime = core === null || core === void 0 ? void 0 : core.makeRenderMimeRegistry(config === null || config === void 0 ? void 0 : config.mathjax);
+        const notebook = notebookFromMdast(core, config, pageSlug, notebookSlug, state.mdast[notebookSlug].root, idkmap, rendermime);
+        // hook up computable targets
+        const computables = (_a = state.pages[pageSlug]) === null || _a === void 0 ? void 0 : _a.computables;
+        computables === null || computables === void 0 ? void 0 : computables.forEach((c) => {
+            if (idkmap[c.label]) {
+                idkmap[c.outputKey] = idkmap[c.label];
+                idkmap[c.embedKey] = idkmap[c.label];
+            }
+        });
+        dispatch({
+            type: 'ADD_NOTEBOOK',
+            payload: { pageSlug, notebookSlug, rendermime, notebook },
+        });
+    }, [core, config, pageSlug, notebookSlug, scopeHasNotebook, lock]);
+    // TODO find a way to check if the all the notebooks are built and do a single dispatch
+    // potentilly use a move the loop down into this component
+    const allNotebooksAreBuilt = selectAreAllNotebookScopesBuilt(state, pageSlug);
+    useEffect(() => {
+        if (!allNotebooksAreBuilt)
+            return;
+        dispatch({ type: 'BUILD_STATUS', payload: { slug: pageSlug, status: 'wait-for-server' } });
+    }, [allNotebooksAreBuilt]);
+    return null;
+}
+export function SessionStarter({ pageSlug, notebookSlug, state, dispatch, }) {
+    var _a;
+    const { core } = useThebeLoader();
+    const { config, server } = useThebeServer();
+    const lock = useRef(false); // TODO can be removed if we solve double render from provider
+    const scope = (_a = state.pages[pageSlug]) === null || _a === void 0 ? void 0 : _a.scopes[notebookSlug];
+    useEffect(() => {
+        if (!core || !server || scope.session || lock.current)
+            return;
+        lock.current = true;
+        console.debug(`Jupyter: Starting session for ${pageSlug}-${notebookSlug}`);
+        server.listRunningSessions().then((sessions) => {
+            console.debug('Jupyter: running sessions', sessions);
+            const path = `/${pageSlug}-${notebookSlug}.ipynb`;
+            const existing = sessions.find((s) => s.path === path);
+            if (existing) {
+                console.debug(`session already exists for ${pageSlug}-${notebookSlug}`, existing);
+                server.connectToExistingSession(existing, scope.rendermime).then((sesh) => {
+                    var _a;
+                    if (sesh == null) {
+                        console.error(`Could not connect to session for ${pageSlug} ${notebookSlug}`);
+                        return;
+                    }
+                    console.debug(`reconnected to session for ${pageSlug}/${notebookSlug}`, sesh);
+                    console.debug('restarting session', sesh);
+                    (_a = sesh.kernel) === null || _a === void 0 ? void 0 : _a.restart().then(() => {
+                        var _a;
+                        const notebook = (_a = state.pages[pageSlug]) === null || _a === void 0 ? void 0 : _a.scopes[notebookSlug].notebook;
+                        notebook.attachSession(sesh);
+                        dispatch({ type: 'ADD_SESSION', payload: { pageSlug, notebookSlug, session: sesh } });
+                    });
+                });
+            }
+            else {
+                server
+                    .startNewSession(scope.rendermime, Object.assign(Object.assign({}, config === null || config === void 0 ? void 0 : config.kernels), { name: `${pageSlug}-${notebookSlug}.ipynb`, path }))
+                    .then((sesh) => {
+                    var _a;
+                    if (sesh == null) {
+                        server === null || server === void 0 ? void 0 : server.getKernelSpecs().then((specs) => {
+                            console.error(`Could not start session for ${pageSlug} ${notebookSlug}`);
+                            console.debug(`Available kernels: ${Object.keys(specs)}`);
+                        });
+                        return;
+                    }
+                    console.debug(`session started for ${pageSlug}/${notebookSlug}`, sesh);
+                    const notebook = (_a = state.pages[pageSlug]) === null || _a === void 0 ? void 0 : _a.scopes[notebookSlug].notebook;
+                    notebook.attachSession(sesh);
+                    dispatch({ type: 'ADD_SESSION', payload: { pageSlug, notebookSlug, session: sesh } });
+                });
+            }
+        });
+    }, [core, config, pageSlug, notebookSlug, lock]);
+    // TODO avoid multiple dispatch?
+    const allSessionsAreStarted = selectAreAllSessionsStarted(state, pageSlug);
+    useEffect(() => {
+        if (!allSessionsAreStarted)
+            return;
+        dispatch({
+            type: 'SET_RENDERING_READY',
+            payload: { slug: pageSlug },
+        });
+    }, [allSessionsAreStarted]);
+    return null;
+}
+export function ServerMonitor({ state, dispatch, }) {
+    const { core, load, loading } = useThebeLoader();
+    const { ready, error } = useThebeServer();
+    useEffect(() => {
+        if (core || loading)
+            return;
+        load();
+    }, [core, load, loading]);
+    // When server is ready, move any waiting builds onto the start session step
+    useEffect(() => {
+        if (ready) {
+            // TODO optimize to do a single dispatch
+            Object.entries(state.builds).forEach(([slug, { status }]) => {
+                if (status === 'wait-for-server') {
+                    dispatch({ type: 'BUILD_STATUS', payload: { slug, status: 'start-session' } });
+                }
+            });
+        }
+    }, [ready, state]);
+    useEffect(() => {
+        if (!error)
+            return;
+        // TODO
+        // dispatch({ type: 'SERVER_ERROR', payload: error });
+    }, [error]);
+    return null;
+}

package/dist/esm/execute/provider.d.ts

@@ -0,0 +1,29 @@
+import type { Dependency } from 'myst-common';
+import { SourceFileKind } from 'myst-common';
+import type { Root } from 'mdast';
+import React from 'react';
+import type { ExecuteScopeAction } from './actions';
+import type { ExecuteScopeState, IdKeyMap } from './types';
+export interface ExecuteScopeType {
+    slug: string;
+    state: ExecuteScopeState;
+    dispatch: React.Dispatch<ExecuteScopeAction>;
+    idkmap: IdKeyMap;
+}
+export declare const ExecuteScopeContext: React.Context<ExecuteScopeType | undefined>;
+type ArticleContents = {
+    slug: string;
+    kind: SourceFileKind;
+    mdast: Root;
+    dependencies?: Dependency[];
+};
+/**
+ *  The ExecuteScopeProvider is responsible for maintaining the state of the
+ *  execution scope. It is also responsible for fetching the json for dependencies
+ *  and adding them to the sources tree.
+ */
+export declare function ExecuteScopeProvider({ children, contents, }: React.PropsWithChildren<{
+    contents: ArticleContents;
+}>): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=provider.d.ts.map

package/dist/esm/execute/provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../../src/execute/provider.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC;AAClC,OAAO,KAAwC,MAAM,OAAO,CAAC;AAE7D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AACpD,OAAO,KAAK,EAAc,iBAAiB,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAUvE,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,iBAAiB,CAAC;IACzB,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC,kBAAkB,CAAC,CAAC;IAC7C,MAAM,EAAE,QAAQ,CAAC;CAClB;AAED,eAAO,MAAM,mBAAmB,6CAA+D,CAAC;AAEhG,KAAK,eAAe,GAAG;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,cAAc,CAAC;IACrB,KAAK,EAAE,IAAI,CAAC;IACZ,YAAY,CAAC,EAAE,UAAU,EAAE,CAAC;CAC7B,CAAC;AA8DF;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,EACnC,QAAQ,EACR,QAAQ,GACT,EAAE,KAAK,CAAC,iBAAiB,CAAC;IAAE,QAAQ,EAAE,eAAe,CAAA;CAAE,CAAC,2CAgGxD"}