jupyterlab-ipyflow 0.0.217 → 0.0.228

package/lib/classes.d.ts

@@ -0,0 +1,22 @@
+declare const _default: {
+    readonly ipyflowClassicColors: string;
+    readonly ipyflowSlice: string;
+    readonly ipyflowSliceExecute: string;
+    readonly jpCell: string;
+    readonly jpCollapser: string;
+    readonly jpCollapserChild: string;
+    readonly jpInputCollapser: string;
+    readonly jpInputPrompt: string;
+    readonly jpModDirty: string;
+    readonly jpModSelected: string;
+    readonly jpNotebook: string;
+    readonly jpOutputCollapser: string;
+    readonly jpWindowedPanelScrollbarContent: string;
+    readonly linkedReadyMaker: string;
+    readonly linkedWaiting: string;
+    readonly readyCell: string;
+    readonly readyMakingCell: string;
+    readonly readyMakingInputCell: string;
+    readonly waitingCell: string;
+};
+export default _default;

package/lib/classes.js

@@ -0,0 +1,13 @@
+import styles from '../style/index.module.css';
+function hyphenToCamel(s) {
+    return s.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
+function makeRawClassMap(styles) {
+    const out = {};
+    for (const key of Object.keys(styles)) {
+        const camel = hyphenToCamel(key);
+        out[camel] = key; // value = original hyphenated class name
+    }
+    return out;
+}
+export default makeRawClassMap(styles);

package/lib/comm/connect.d.ts

@@ -0,0 +1,16 @@
+import { ISessionContext } from '@jupyterlab/apputils';
+import { IDocumentManager } from '@jupyterlab/docmanager';
+import { INotebookTracker, Notebook } from '@jupyterlab/notebook';
+/**
+ * Establish the ipyflow comm for a notebook session: create the store, build
+ * the connection context, wire the notebook event handlers and message
+ * dispatcher, and open the comm. Returns a disconnect handler that tears the
+ * connection down.
+ */
+export declare function connectToComm(session: ISessionContext, notebooks: INotebookTracker, notebook: Notebook, docManager: IDocumentManager): () => void;
+/**
+ * Activate-time wiring: track the foreground notebook for the debug hook and
+ * register the `ipyflow-client` comm target (plus kernel-restart handling) for
+ * each notebook as it is added.
+ */
+export declare function setupComm(notebooks: INotebookTracker, docManager: IDocumentManager): void;

package/lib/comm/connect.js

@@ -0,0 +1,138 @@
+import { clearDebugStore, getStore, initStore, resetStore, setDebugStore, } from '../state/registry';
+import { updateUI } from '../ui/decorations';
+import { clearCellState } from '../ui/dom';
+import { createMessageHandler } from './messageHandlers';
+import { createNotebookEventHandlers } from './notebookEvents';
+/**
+ * Establish the ipyflow comm for a notebook session: create the store, build
+ * the connection context, wire the notebook event handlers and message
+ * dispatcher, and open the comm. Returns a disconnect handler that tears the
+ * connection down.
+ */
+export function connectToComm(session, notebooks, notebook, docManager) {
+    const store = initStore(session.session.id);
+    store.activeCell = notebook.activeCell;
+    store.comm = session.session.kernel.createComm('ipyflow', 'ipyflow');
+    store.notebook = notebook;
+    store.session = session;
+    const ipyflowMetadata = notebook.model.getMetadata?.('ipyflow') ?? {};
+    const ctx = {
+        store,
+        session,
+        notebooks,
+        notebook,
+        docManager,
+        disconnected: false,
+        onEstablishPayload: null,
+        ipyflowMetadata,
+        safeSend: null, // assigned just below
+    };
+    const commDisconnectHandler = () => {
+        if (!store.comm.isDisposed) {
+            store.comm.dispose();
+        }
+        ctx.disconnected = true;
+        store.isIpyflowCommConnected = false;
+        resetStore(session.session.id);
+    };
+    const safeSend = (data) => {
+        if (ctx.disconnected) {
+            return;
+        }
+        else if (store.comm.isDisposed) {
+            ctx.onEstablishPayload = data;
+            const oldComm = store.comm;
+            store.comm = session.session.kernel.createComm('ipyflow', 'ipyflow');
+            store.comm.onMsg = oldComm.onMsg;
+            store.comm.open({
+                interface: 'jupyterlab',
+                cell_metadata_by_id: store.gatherCellMetadataAndContent(),
+                cell_parents: ctx.ipyflowMetadata?.cell_parents ?? {},
+                cell_children: ctx.ipyflowMetadata?.cell_children ?? {},
+            });
+        }
+        else {
+            store.comm.send(data);
+        }
+    };
+    ctx.safeSend = safeSend;
+    store.safeSend = safeSend;
+    const handlers = createNotebookEventHandlers(ctx);
+    // Wire the listeners that must be live before `establish`.
+    for (const cell of notebook.widgets) {
+        cell.model.stateChanged.connect(handlers.onExecution);
+    }
+    notebook.model.cells.changed.connect(handlers.onCellsAdded);
+    notebooks.selectionChanged.connect(handlers.onSelectionChanged);
+    // Re-render decorations whenever the store signals a change.
+    store.changed.connect(() => updateUI(store, notebooks));
+    store.comm.onMsg = createMessageHandler(ctx, handlers);
+    store.comm.open({
+        interface: 'jupyterlab',
+        cell_metadata_by_id: store.gatherCellMetadataAndContent(),
+        cell_parents: ctx.ipyflowMetadata?.cell_parents ?? {},
+        cell_children: ctx.ipyflowMetadata?.cell_children ?? {},
+    });
+    return commDisconnectHandler;
+}
+/**
+ * Activate-time wiring: track the foreground notebook for the debug hook and
+ * register the `ipyflow-client` comm target (plus kernel-restart handling) for
+ * each notebook as it is added.
+ */
+export function setupComm(notebooks, docManager) {
+    notebooks.currentChanged.connect((_, nbPanel) => {
+        const session = nbPanel.sessionContext;
+        if (session?.session == null) {
+            clearDebugStore();
+            return;
+        }
+        const store = getStore(session.session.id);
+        setDebugStore(store ?? null);
+        if (store?.isIpyflowCommConnected ?? false) {
+            store.requestComputeExecSchedule();
+        }
+    });
+    notebooks.widgetAdded.connect((_sender, nbPanel) => {
+        const session = nbPanel.sessionContext;
+        let commDisconnectHandler = () => resetStore(session.session.id);
+        const registerCommTarget = () => {
+            session.session.kernel.registerCommTarget('ipyflow-client', (comm, _open_msg) => {
+                comm.onMsg = (msg) => {
+                    const payload = msg.content.data;
+                    if (!(payload.success ?? true)) {
+                        return;
+                    }
+                    if (payload.type === 'unestablish') {
+                        commDisconnectHandler();
+                    }
+                    else if (payload.type === 'establish') {
+                        commDisconnectHandler();
+                        commDisconnectHandler = connectToComm(session, notebooks, nbPanel.content, docManager);
+                    }
+                };
+                commDisconnectHandler();
+                commDisconnectHandler = connectToComm(session, notebooks, nbPanel.content, docManager);
+            });
+        };
+        session.ready.then(() => {
+            clearCellState(nbPanel.content);
+            registerCommTarget();
+            commDisconnectHandler();
+            commDisconnectHandler = connectToComm(session, notebooks, nbPanel.content, docManager);
+            session.kernelChanged.connect((_, args) => {
+                if (args.newValue == null) {
+                    return;
+                }
+                clearCellState(nbPanel.content);
+                commDisconnectHandler();
+                resetStore(session.session.id);
+                commDisconnectHandler = () => resetStore(session.session.id);
+                session.ready.then(() => {
+                    registerCommTarget();
+                    commDisconnectHandler = connectToComm(session, notebooks, nbPanel.content, docManager);
+                });
+            });
+        });
+    });
+}

package/lib/comm/context.d.ts

@@ -0,0 +1,27 @@
+import { ISessionContext } from '@jupyterlab/apputils';
+import { IDocumentManager } from '@jupyterlab/docmanager';
+import { INotebookTracker, Notebook } from '@jupyterlab/notebook';
+import { JSONValue } from '@lumino/coreutils';
+import { IpyflowSessionStore } from '../state/SessionStore';
+/**
+ * Mutable per-connection context shared by the comm lifecycle, the notebook
+ * event handlers, the message dispatcher, and the schedule handler. Bundling
+ * the closure state that `connectToComm` used to capture lets those concerns
+ * live in separate modules while still sharing the same `disconnected` flag,
+ * deferred establish payload, etc.
+ */
+export interface IConnectionContext {
+    store: IpyflowSessionStore;
+    session: ISessionContext;
+    notebooks: INotebookTracker;
+    notebook: Notebook;
+    docManager: IDocumentManager;
+    /** Set true by the disconnect handler; read by every handler to bail out. */
+    disconnected: boolean;
+    /** Payload buffered while the comm is re-created, replayed on establish. */
+    onEstablishPayload: JSONValue | null;
+    /** ipyflow metadata read off the notebook model at connect time. */
+    ipyflowMetadata: any;
+    /** Send that transparently re-creates a disposed comm. */
+    safeSend: (data: JSONValue) => void;
+}

package/lib/comm/context.js

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

package/lib/comm/messageHandlers.d.ts

@@ -0,0 +1,10 @@
+import { KernelMessage } from '@jupyterlab/services';
+import { IConnectionContext } from './context';
+import { INotebookEventHandlers } from './notebookEvents';
+/**
+ * Build the `comm.onMsg` dispatcher. On `establish` it wires up the
+ * active-cell/content/execution listeners and flushes any buffered payload; on
+ * `set_exec_mode` it records the mode; `compute_exec_schedule` is delegated to
+ * the schedule handler.
+ */
+export declare function createMessageHandler(ctx: IConnectionContext, handlers: INotebookEventHandlers): (msg: KernelMessage.ICommMsgMsg) => void;

package/lib/comm/messageHandlers.js

@@ -0,0 +1,40 @@
+import { refreshNodeMapping } from '../ui/decorations';
+import { handleComputeExecSchedule } from './schedule';
+/**
+ * Build the `comm.onMsg` dispatcher. On `establish` it wires up the
+ * active-cell/content/execution listeners and flushes any buffered payload; on
+ * `set_exec_mode` it records the mode; `compute_exec_schedule` is delegated to
+ * the schedule handler.
+ */
+export function createMessageHandler(ctx, handlers) {
+    const { store, notebook } = ctx;
+    return (msg) => {
+        const payload = msg.content.data;
+        if (ctx.disconnected || !(payload.success ?? true)) {
+            return;
+        }
+        if (payload.type === 'establish') {
+            notebook.scrollbar = true;
+            store.isIpyflowCommConnected = true;
+            refreshNodeMapping(store, notebook);
+            notebook.activeCellChanged.connect(handlers.onActiveCellChange);
+            notebook.activeCell.model.stateChanged.connect(handlers.onExecution);
+            handlers.onActiveCellChange(notebook, notebook.activeCell);
+            notebook.model.contentChanged.connect(handlers.onContentChanged);
+            notebook.model.cells.changed.connect(handlers.onContentChanged);
+            if (ctx.onEstablishPayload !== null) {
+                const toSend = ctx.onEstablishPayload;
+                ctx.onEstablishPayload = null;
+                ctx.safeSend(toSend);
+            }
+            store.requestComputeExecSchedule();
+        }
+        else if (payload.type === 'set_exec_mode') {
+            store.numAltModeExecutes = 0;
+            store.settings.exec_mode = payload.exec_mode;
+        }
+        else if (payload.type === 'compute_exec_schedule') {
+            handleComputeExecSchedule(ctx, handlers.debouncedSave, payload);
+        }
+    };
+}

package/lib/comm/notebookEvents.d.ts

@@ -0,0 +1,22 @@
+import { Cell, ICellModel } from '@jupyterlab/cells';
+import type { IChangedArgs } from '@jupyterlab/coreutils/lib/interfaces';
+import { CellList, Notebook } from '@jupyterlab/notebook';
+import type { IObservableList } from '@jupyterlab/observables';
+import { IConnectionContext } from './context';
+export interface INotebookEventHandlers {
+    syncDirtiness: (cell: Cell<ICellModel>) => void;
+    onContentChanged: () => void;
+    onExecution: (cell: ICellModel, args: IChangedArgs<any>) => void;
+    onCellsAdded: (cells: CellList, change: IObservableList.IChangedArgs<ICellModel>) => void;
+    notifyActiveCell: (newActiveCell: ICellModel) => void;
+    onActiveCellChange: (nb: Notebook, cell: Cell<ICellModel>) => void;
+    onSelectionChanged: () => void;
+    debouncedSave: () => void;
+}
+/**
+ * Build the set of notebook/selection event handlers bound to a connection
+ * context. They are wired up at different points (connect time vs. establish),
+ * so they are created once here and shared. UI updates are signalled via
+ * `store.emitChanged()` rather than calling the renderer directly.
+ */
+export declare function createNotebookEventHandlers(ctx: IConnectionContext): INotebookEventHandlers;

package/lib/comm/notebookEvents.js

@@ -0,0 +1,166 @@
+import { JSONExt } from '@lumino/coreutils';
+import classes from '../classes';
+import { getStore } from '../state/registry';
+import { debounce } from '../utils';
+/**
+ * Build the set of notebook/selection event handlers bound to a connection
+ * context. They are wired up at different points (connect time vs. establish),
+ * so they are created once here and shared. UI updates are signalled via
+ * `store.emitChanged()` rather than calling the renderer directly.
+ */
+export function createNotebookEventHandlers(ctx) {
+    const { store, notebook, notebooks, docManager } = ctx;
+    const syncDirtiness = (cell) => {
+        if (cell !== null && cell.model !== null) {
+            if (cell.model.isDirty) {
+                store.dirtyCells.add(cell.model.id);
+            }
+            else {
+                store.dirtyCells.delete(cell.model.id);
+            }
+        }
+    };
+    const onContentChanged = debounce(() => {
+        if (ctx.disconnected) {
+            notebook.model.contentChanged.disconnect(onContentChanged);
+            notebook.model.cells.changed.disconnect(onContentChanged);
+            return;
+        }
+        const cell_metadata_by_id = store.gatherCellMetadataAndContent();
+        if (JSONExt.deepEqual(cell_metadata_by_id, store.lastCellMetadataMap)) {
+            // fixes https://github.com/ipyflow/ipyflow/issues/145
+            return;
+        }
+        store.lastCellMetadataMap = cell_metadata_by_id;
+        notebook.widgets.forEach(syncDirtiness);
+        ctx.safeSend({
+            type: 'notify_content_changed',
+            cell_metadata_by_id,
+        });
+    }, 500);
+    const onExecution = (cell, args) => {
+        if (ctx.disconnected) {
+            cell.stateChanged.disconnect(onExecution);
+            return;
+        }
+        if (args.name !== 'executionCount' || args.newValue === null) {
+            return;
+        }
+        store.executedCells.add(cell.id);
+        store.dirtyCells.delete(cell.id);
+        notebook.widgets.forEach((itercell) => {
+            if (itercell.model.id === cell.id) {
+                itercell.node.classList.remove(classes.readyCell);
+                itercell.node.classList.remove(classes.readyMakingInputCell);
+            }
+        });
+    };
+    const onCellsAdded = (_cells, change) => {
+        if (ctx.disconnected) {
+            notebook.model.cells.changed.disconnect(onCellsAdded);
+            return;
+        }
+        if (change.type === 'add') {
+            for (const cell of change.newValues) {
+                cell?.stateChanged.connect(onExecution);
+            }
+        }
+        else if (change.type === 'remove') {
+            for (const cell of change.oldValues) {
+                cell?.stateChanged.disconnect(onExecution);
+            }
+        }
+    };
+    const notifyActiveCell = (newActiveCell) => {
+        if (newActiveCell.id == null) {
+            return;
+        }
+        let newActiveCellOrderIdx = -1;
+        notebook.widgets.forEach((itercell, idx) => {
+            if (itercell.model.id === newActiveCell.id) {
+                newActiveCellOrderIdx = idx;
+            }
+        });
+        ctx.safeSend({
+            type: 'change_active_cell',
+            active_cell_id: newActiveCell.id,
+            active_cell_order_idx: newActiveCellOrderIdx,
+        });
+    };
+    const onActiveCellChange = (nb, cell) => {
+        if (notebook !== nb) {
+            return;
+        }
+        if (ctx.disconnected) {
+            notebook.activeCellChanged.disconnect(onActiveCellChange);
+            return;
+        }
+        notifyActiveCell(cell.model);
+        store.prevActiveCell = store.activeCell;
+        store.activeCell = cell;
+        if (store.activeCell === null ||
+            store.activeCell.model === null ||
+            store.activeCell.model.type !== 'code') {
+            return;
+        }
+        if (store.dirtyCells.has(store.activeCell.model.id)) {
+            store.activeCell.model._setDirty?.(true);
+        }
+        store.emitChanged();
+    };
+    const onSelectionChanged = () => {
+        if (ctx.disconnected) {
+            notebooks.selectionChanged.disconnect(onSelectionChanged);
+        }
+        const nbPanel = notebooks?.currentWidget;
+        const session = nbPanel?.sessionContext;
+        if (!(session?.isReady ?? false)) {
+            return;
+        }
+        const selectionStore = getStore(session.session.id);
+        if (!(selectionStore?.isIpyflowCommConnected ?? false)) {
+            return;
+        }
+        const selectionNotebook = nbPanel.content;
+        selectionStore.selectedCells = selectionNotebook.widgets
+            .filter((cell) => cell.model.type === 'code' && selectionNotebook.isSelected(cell))
+            .map((cell) => cell.model.id);
+        selectionStore.emitChanged();
+    };
+    const debouncedSave = debounce(() => {
+        if (ctx.disconnected) {
+            return;
+        }
+        // Persist ipyflow metadata by saving *this connection's* notebook (not
+        // whatever happens to be focused), and only if it is still open. The save
+        // is debounced, so by the time it fires the notebook may have been closed
+        // (context disposed) or its file removed; calling context.save() then makes
+        // JupyterLab surface a "File Save Error" dialog itself, so guard first.
+        const nbPanel = notebooks.find((panel) => panel.content === notebook);
+        if (nbPanel == null ||
+            nbPanel.isDisposed ||
+            nbPanel.context == null ||
+            nbPanel.context.isDisposed) {
+            return;
+        }
+        if (nbPanel.context.model?.collaborative ?? false) {
+            return;
+        }
+        else if (docManager.autosave && docManager.autosaveInterval <= 5) {
+            return;
+        }
+        // Still possible for the file to vanish between this check and the write;
+        // swallow that transient rejection rather than leaving it unhandled.
+        void nbPanel.context.save().catch(() => undefined);
+    }, 200);
+    return {
+        syncDirtiness,
+        onContentChanged,
+        onExecution,
+        onCellsAdded,
+        notifyActiveCell,
+        onActiveCellChange,
+        onSelectionChanged,
+        debouncedSave,
+    };
+}

package/lib/comm/schedule.d.ts

@@ -0,0 +1,10 @@
+import { IConnectionContext } from './context';
+/**
+ * Handle a `compute_exec_schedule` message: absorb the kernel's view of the
+ * dependency graph and reactive state, drive the next batch/incremental
+ * reactive execution step, and emit a UI refresh once the reactive cascade for
+ * this round has settled. Ported verbatim from the original monolithic
+ * `comm.onMsg` handler, with `state` -> `ctx.store` and the direct `updateUI`
+ * call replaced by `store.emitChanged()`.
+ */
+export declare function handleComputeExecSchedule(ctx: IConnectionContext, debouncedSave: () => void, payload: any): void;

package/lib/comm/schedule.js

@@ -0,0 +1,165 @@
+import { drainDeferredCells, hasDeferredCells } from '../state/deferred';
+import { mergeMaps } from '../utils';
+/**
+ * Handle a `compute_exec_schedule` message: absorb the kernel's view of the
+ * dependency graph and reactive state, drive the next batch/incremental
+ * reactive execution step, and emit a UI refresh once the reactive cascade for
+ * this round has settled. Ported verbatim from the original monolithic
+ * `comm.onMsg` handler, with `state` -> `ctx.store` and the direct `updateUI`
+ * call replaced by `store.emitChanged()`.
+ */
+export function handleComputeExecSchedule(ctx, debouncedSave, payload) {
+    const { store, notebook } = ctx;
+    store.settings = payload.settings;
+    const ipyflow_metadata = notebook.model.getMetadata?.('ipyflow') ?? {};
+    const parentsFromMetadata = ipyflow_metadata?.cell_parents ?? {};
+    const childrenFromMetadata = ipyflow_metadata?.cell_children ?? {};
+    store.cellParents = mergeMaps(payload.cell_parents, parentsFromMetadata);
+    store.cellChildren = mergeMaps(payload.cell_children, childrenFromMetadata);
+    store.executedCells = new Set(payload.executed_cells);
+    notebook.model.setMetadata?.('ipyflow', {
+        cell_parents: store.cellParents,
+        cell_children: store.cellChildren,
+    });
+    debouncedSave();
+    store.waitingCells = new Set(payload.waiting_cells);
+    store.readyCells = new Set(payload.ready_cells);
+    store.forcedReactiveCells = new Set([
+        ...store.forcedReactiveCells,
+        ...payload.forced_reactive_cells,
+    ]);
+    store.waiterLinks = payload.waiter_links;
+    store.readyMakerLinks = payload.ready_maker_links;
+    store.staleParents = payload.stale_parents;
+    store.staleParentsByExecutedCellByChild =
+        payload.stale_parents_by_executed_cell_by_child;
+    store.staleParentsByChildByExecutedCell =
+        payload.stale_parents_by_child_by_executed_cell;
+    store.cellPendingExecution = null;
+    const exec_mode = payload.exec_mode;
+    store.isReactivelyExecuting =
+        store.isReactivelyExecuting ||
+            (payload?.is_reactively_executing ?? false) ||
+            exec_mode === 'reactive';
+    if (exec_mode === 'reactive') {
+        store.newReadyCells = new Set([
+            ...store.newReadyCells,
+            ...payload.new_ready_cells,
+        ]);
+    }
+    else {
+        store.newReadyCells = new Set();
+    }
+    const flow_order = payload.flow_order;
+    const exec_schedule = payload.exec_schedule;
+    store.lastExecutionHighlights = payload.highlights;
+    const lastExecutedCellId = payload.last_executed_cell_id;
+    store.executedReactiveReadyCells.add(lastExecutedCellId);
+    if (hasDeferredCells()) {
+        const cells = drainDeferredCells();
+        if (store.isBatchReactive()) {
+            store.executeClosure(cells);
+        }
+        else {
+            store.executeCells(cells);
+        }
+        return;
+    }
+    const last_execution_was_error = payload.last_execution_was_error;
+    let doneReactivelyExecuting = false;
+    if (last_execution_was_error) {
+        doneReactivelyExecuting = true;
+    }
+    else if (store.settings.reactivity_mode === 'batch') {
+        let reactiveCells;
+        if (exec_mode === 'reactive') {
+            reactiveCells = store
+                .computeTransitiveClosure([...store.newReadyCells, ...store.forcedReactiveCells].filter((id) => !store.executedReactiveReadyCells.has(id)))
+                .filter((cell) => !store.executedReactiveReadyCells.has(cell.model.id));
+        }
+        else {
+            reactiveCells = [...store.forcedReactiveCells]
+                .filter((id) => !store.executedReactiveReadyCells.has(id) &&
+                store.cellsById[id] !== undefined &&
+                store.orderIdxById[id] !== undefined)
+                .sort((a, b) => store.orderIdxById[a] - store.orderIdxById[b])
+                .map((id) => store.cellsById[id]);
+        }
+        if (reactiveCells.length === 0) {
+            doneReactivelyExecuting = true;
+        }
+        else {
+            store.isReactivelyExecuting = true;
+            store.executedReactiveReadyCells = new Set([
+                ...store.executedReactiveReadyCells,
+                ...reactiveCells.map((cell) => cell.model.id),
+            ]);
+            store.executeCells(reactiveCells);
+        }
+    }
+    else if (store.settings.reactivity_mode === 'incremental') {
+        let lastExecutedCellIdSeen = false;
+        for (const cell of notebook.widgets) {
+            if (!lastExecutedCellIdSeen) {
+                lastExecutedCellIdSeen = cell.model.id === lastExecutedCellId;
+                if (flow_order === 'in_order' || exec_schedule === 'strict') {
+                    continue;
+                }
+            }
+            if (cell.model.type !== 'code' ||
+                store.executedReactiveReadyCells.has(cell.model.id)) {
+                continue;
+            }
+            if (!store.forcedReactiveCells.has(cell.model.id)) {
+                if (!store.newReadyCells.has(cell.model.id) ||
+                    exec_mode !== 'reactive') {
+                    continue;
+                }
+            }
+            const codeCell = cell;
+            if (store.cellPendingExecution === null) {
+                store.cellPendingExecution = codeCell;
+                // break early if using one of the order-based semantics
+                if (flow_order === 'in_order' || exec_schedule === 'strict') {
+                    break;
+                }
+            }
+            else if (codeCell.model.executionCount == null) {
+                // pass
+            }
+            else if (codeCell.model.executionCount <
+                store.cellPendingExecution.model.executionCount) {
+                // otherwise, execute in order of earliest execution counter
+                store.cellPendingExecution = codeCell;
+            }
+        }
+        if (store.cellPendingExecution === null) {
+            doneReactivelyExecuting = true;
+        }
+        else {
+            store.isReactivelyExecuting = true;
+            store.executedCells.add(store.cellPendingExecution.model.id);
+            store.executeCells([store.cellPendingExecution]);
+        }
+    }
+    if (doneReactivelyExecuting) {
+        if (store.isReactivelyExecuting) {
+            if (store.lastExecutionHighlights === 'reactive') {
+                store.readyCells = store.executedReactiveReadyCells;
+            }
+            ctx.safeSend({
+                type: 'reactivity_cleanup',
+            });
+        }
+        if (store.numAltModeExecutes > 0 &&
+            --store.numAltModeExecutes === 0 &&
+            store.settings.reactivity_mode === 'incremental') {
+            store.toggleReactivity();
+        }
+        store.forcedReactiveCells = new Set();
+        store.newReadyCells = new Set();
+        store.executedReactiveReadyCells = new Set();
+        store.isReactivelyExecuting = false;
+        store.emitChanged();
+    }
+}

package/lib/commands/commands.d.ts

@@ -0,0 +1,9 @@
+import { JupyterFrontEnd } from '@jupyterlab/application';
+import { ICommandPalette } from '@jupyterlab/apputils';
+import { INotebookTracker } from '@jupyterlab/notebook';
+/**
+ * Register the ipyflow execution commands (and their keybindings / palette
+ * entries): run-ready-cells, alt-mode execute, and forward/backward slice
+ * execution.
+ */
+export declare function registerCommands(app: JupyterFrontEnd, notebooks: INotebookTracker, palette: ICommandPalette): void;