nebula-notebook 0.1.1 → 0.2.1

package/node-server/dist/routes/kernel.js

@@ -45,10 +45,13 @@ const path = __importStar(require("path"));
 const os = __importStar(require("os"));
 const kernel_service_1 = require("../kernel/kernel-service");
 const kernelspec_1 = require("../kernel/kernelspec");
+const discovery_service_1 = require("../discovery/discovery-service");
+const types_1 = require("../discovery/types");
 const fs_service_1 = require("../fs/fs-service");
 const operation_router_1 = require("../notebook/operation-router");
 const kernel_proxy_1 = require("../cluster/kernel-proxy");
 const server_registry_1 = require("../cluster/server-registry");
+const allocation_service_1 = require("../scheduler/allocation-service");
 // Track all WebSocket connections per kernel session for broadcasting
 const sessionWebSockets = new Map();
 // Only send streaming outputs to sockets after they've performed an initial output sync.
@@ -58,12 +61,61 @@ const outputSubscribedSockets = new WeakSet();
 // Shared kernel service instance - exported for use by headless handler
 const kernelService = new kernel_service_1.KernelService();
 exports.kernelService = kernelService;
+// When a kernel dies (crash, OOM, reattached PID gone), push the status to
+// every client immediately — otherwise the UI shows 'busy' until the next
+// poll or failed execute.
+kernelService.onSessionDead((sessionId) => {
+    const sockets = sessionWebSockets.get(sessionId);
+    if (!sockets || sockets.size === 0)
+        return;
+    const msg = JSON.stringify({ type: 'status', status: 'dead' });
+    for (const socket of sockets) {
+        try {
+            if (socket.readyState === ws_1.WebSocket.OPEN)
+                socket.send(msg);
+        }
+        catch {
+            // Socket already closing — the reconnect loop will handle it
+        }
+    }
+});
+// Broadcast kernel-originated comm messages (ipywidgets state sync, etc.) to
+// every client attached to the session. This includes idle-time traffic from
+// widget observers — comm messages are demuxed regardless of parent request.
+kernelService.onComm((sessionId, comm) => {
+    const sockets = sessionWebSockets.get(sessionId);
+    if (!sockets || sockets.size === 0)
+        return;
+    const msg = JSON.stringify({
+        type: 'comm',
+        comm: {
+            msg_type: comm.msgType,
+            comm_id: comm.commId,
+            ...(comm.targetName !== undefined && { target_name: comm.targetName }),
+            data: comm.data,
+            ...(comm.buffers && { buffers: comm.buffers }),
+        },
+    });
+    for (const socket of sockets) {
+        try {
+            if (socket.readyState === ws_1.WebSocket.OPEN)
+                socket.send(msg);
+        }
+        catch {
+            // Socket already closing — the reconnect loop will handle it
+        }
+    }
+});
 // Initialize kernel service on module load
 kernelService.initialize().catch(err => {
     console.error('Failed to initialize kernel service:', err);
 });
 function buildKernelMetadata(kernelName) {
-    const spec = (0, kernelspec_1.getKernelSpec)(kernelName);
+    // env: kernels have no on-disk spec — synthesize one, preferring the
+    // discovery cache's label ("Python 3.10 (conda: hypir)") over the raw path.
+    const envPython = (0, kernelspec_1.envKernelPythonPath)(kernelName);
+    const cachedLabel = envPython ? discovery_service_1.pythonDiscovery.getFromCache()?.[envPython]?.displayName : undefined;
+    const spec = (0, kernelspec_1.resolveKernelSpec)(kernelName, cachedLabel);
     return {
         kernelspec: {
             name: kernelName,
@@ -72,6 +124,20 @@ function buildKernelMetadata(kernelName) {
         },
     };
 }
+/**
+ * Map provisioning failures to structured responses (matching routes/python.ts)
+ * so the UI can branch on `code` — e.g. open the ipykernel install prompt —
+ * instead of parsing error prose. Returns true if the error was handled.
+ */
+function sendProvisionError(reply, err) {
+    if (!(err instanceof types_1.KernelProvisionError))
+        return false;
+    const status = err.code === 'python_not_found' ? 404
+        : err.code === 'externally_managed' || err.code === 'needs_ipykernel' ? 422
+            : 500;
+    reply.code(status).send({ detail: err.message, code: err.code, install_hint: err.installHint });
+    return true;
+}
 async function persistNotebookKernelMetadata(filePath, kernelName) {
     // Best-effort: persisting the kernel choice into the notebook's metadata is a
     // secondary side-effect. If it fails (e.g. the notebook file doesn't exist yet,
@@ -190,6 +256,41 @@ function setupKernelWebSocket(wss) {
                     const result = await kernelService.complete(sessionId, code, cursorPos);
                     ws.send(JSON.stringify({ type: 'complete_reply', result }));
                 }
+                else if (message.type === 'comm') {
+                    // Client -> kernel comm message (ipywidgets interaction):
+                    // { type: 'comm', comm: { msg_type, comm_id, target_name?, data, buffers? } }
+                    const comm = (message.comm && typeof message.comm === 'object') ? message.comm : {};
+                    const msgType = comm.msg_type;
+                    if (msgType !== 'comm_open' && msgType !== 'comm_msg' && msgType !== 'comm_close') {
+                        ws.send(JSON.stringify({ type: 'error', error: `Invalid comm msg_type: ${String(msgType)}` }));
+                        return;
+                    }
+                    if (typeof comm.comm_id !== 'string' || comm.comm_id.length === 0) {
+                        ws.send(JSON.stringify({ type: 'error', error: 'comm.comm_id is required' }));
+                        return;
+                    }
+                    const content = {
+                        comm_id: comm.comm_id,
+                        data: (comm.data && typeof comm.data === 'object') ? comm.data : {},
+                    };
+                    if (msgType === 'comm_open') {
+                        content.target_name = typeof comm.target_name === 'string' ? comm.target_name : '';
+                    }
+                    const buffers = Array.isArray(comm.buffers)
+                        ? comm.buffers.filter((b) => typeof b === 'string')
+                        : undefined;
+                    await kernelService.sendCommMessage(sessionId, msgType, content, buffers);
+                }
+                else if (message.type === 'comm_info') {
+                    // Late-joiner support: list open comms known for this session.
+                    // Reply only to the requesting socket.
+                    const openComms = kernelService.getOpenComms(sessionId);
+                    const comms = {};
+                    for (const [commId, info] of Object.entries(openComms)) {
+                        comms[commId] = { target_name: info.targetName };
+                    }
+                    ws.send(JSON.stringify({ type: 'comm_info_reply', comms }));
+                }
             }
             catch (err) {
                 const errMessage = err instanceof Error ? err.message : 'Unknown error';
@@ -340,6 +441,10 @@ async function kernelRoutes(fastify) {
                 return reply.code(500).send({ detail: message });
             }
         }
+        // Confirmed-dead rows (process gone) are auto-removed without user
+        // confirmation — only ambiguous leftovers (PID still alive) are reported
+        // for the explicit Clean Up flow.
+        await kernelService.autoCleanupDeadSessions().catch(() => { });
         const deadSessions = kernelService.getDeadSessions();
         const sessions = deadSessions.map(s => ({
             session_id: s.sessionId,
@@ -413,6 +518,8 @@ async function kernelRoutes(fastify) {
             return reply.send({ session_id: sessionId, kernel_name, server_id: localServerId, mtime: notebookMtime });
         }
         catch (err) {
+            if (sendProvisionError(reply, err))
+                return reply;
             const message = err instanceof Error ? err.message : 'Unknown error';
             return reply.code(500).send({ detail: message });
         }
@@ -441,7 +548,7 @@ async function kernelRoutes(fastify) {
      */
     fastify.post('/kernels/for-file', async (request, reply) => {
         try {
-            const { file_path, kernel_name = 'python3', server_id, client_origin } = request.body;
+            const { file_path, kernel_name, server_id, client_origin } = request.body;
             if (!file_path) {
                 return reply.code(400).send({ detail: 'file_path is required' });
             }
@@ -463,6 +570,25 @@ async function kernelRoutes(fastify) {
                     }
                 }
             }
+            // No explicit kernel and no saved preference: resolve from the
+            // notebook's own kernelspec metadata (headless callers — CLI/MCP —
+            // don't resolve it client-side the way the UI does). Only then fall
+            // back to python3.
+            if (!effectiveKernelName) {
+                try {
+                    const metadata = await fs_service_1.fsService.getNotebookMetadataAsync(normalizedFilePath);
+                    const specName = metadata.kernelspec?.name;
+                    if (specName) {
+                        effectiveKernelName = specName;
+                    }
+                }
+                catch {
+                    // fall through to the default
+                }
+            }
+            if (!effectiveKernelName) {
+                effectiveKernelName = 'python3';
+            }
             // Check if we should start on a remote server
             if (effectiveServerId && effectiveServerId !== localServerId && effectiveServerId !== 'local') {
                 // Start on remote server
@@ -509,6 +635,8 @@ async function kernelRoutes(fastify) {
             });
         }
         catch (err) {
+            if (sendProvisionError(reply, err))
+                return reply;
             const message = err instanceof Error ? err.message : 'Unknown error';
             return reply.code(500).send({ detail: message });
         }
@@ -612,10 +740,35 @@ async function kernelRoutes(fastify) {
         if ((0, kernel_proxy_1.isProxiedSession)(sessionId)) {
             try {
                 const remoteStatus = await (0, kernel_proxy_1.getRemoteKernelStatus)(sessionId);
-                return reply.send(remoteStatus);
+                // Return the COMPOSITE session id (serverId::remoteId) — the remote
+                // server reports its own local id, and leaking that to clients makes
+                // them reference a session the main server doesn't recognize.
+                return reply.send({ ...remoteStatus, id: sessionId });
             }
             catch (err) {
                 const message = err instanceof Error ? err.message : 'Unknown error';
+                // "Server is offline / not found" from the registry is a HEARTBEAT
+                // signal, not ground truth: a compute node saturated by a heavy
+                // execution can miss heartbeats for minutes while its SLURM job (and
+                // kernel) are perfectly alive — then recover. Treating that as
+                // terminal permanently killed live kernels (red kernel, reconnect
+                // loop stopped, only a page refresh recovered).
+                //
+                // The scheduler is the authority: return 410 Gone (terminal) only
+                // when the session's allocation is confirmed ended/failed/cancelled
+                // by squeue polling. Everything else is 503 (transient) so the
+                // client's reconnect loop keeps trying and revives the kernel when
+                // the node recovers.
+                if (/server (is offline|not found)/i.test(message)) {
+                    const { serverId } = (0, kernel_proxy_1.parseSessionId)(sessionId);
+                    const allocation = serverId
+                        ? allocation_service_1.allocationService.list().find(a => a.serverId === serverId)
+                        : undefined;
+                    if (allocation && ['ended', 'failed', 'cancelled'].includes(allocation.state)) {
+                        return reply.code(410).send({ detail: `Allocation ${allocation.state} — kernel stopped`, reason: 'server_gone' });
+                    }
+                    return reply.code(503).send({ detail: `${message} (may be transient — compute node busy or re-registering)`, reason: 'server_unreachable' });
+                }
                 return reply.code(500).send({ detail: message });
             }
         }

package/node-server/dist/routes/notebook.js

@@ -87,6 +87,12 @@ async function notebookRoutes(fastify) {
                 return reply.code(400).send({ detail: 'cells is required' });
             }
             const result = await fs_service_1.fsService.saveNotebookBundle(filePath, cells, kernel_name, history);
+            // Outputs-unchanged sentinel couldn't be resolved against the file on
+            // disk (first save, changed ids, external rewrite…) — tell the client
+            // to resend the full payload.
+            if (!result.success && result.needsFull) {
+                return reply.code(409).send({ detail: 'unchanged-outputs sentinel unresolved; resend full payload', code: 'needs_full' });
+            }
             // The UI just wrote newer content than whatever the headless handler may
             // have cached. Drop the cache so headless ops (an agent working after the
             // user closes the tab) reload from disk instead of serving — or worse,
@@ -109,7 +115,7 @@ async function notebookRoutes(fastify) {
             if (!notebookPath) {
                 return reply.code(400).send({ detail: 'notebook_path query parameter is required' });
             }
-            const history = fs_service_1.fsService.loadHistory(notebookPath);
+            const history = await fs_service_1.fsService.loadHistory(notebookPath);
             return reply.send({ notebook_path: notebookPath, history });
         }
         catch (err) {
@@ -184,7 +190,8 @@ async function notebookRoutes(fastify) {
             return reply.send({
                 status: 'ok',
                 notebook_path,
-                ...(result.status || fs_service_1.fsService.getAgentPermissionStatus(notebook_path)),
+                mtime: result.mtime,
+                ...(result.status || await fs_service_1.fsService.getAgentPermissionStatusAsync(notebook_path)),
             });
         }
         catch (err) {
@@ -201,7 +208,7 @@ async function notebookRoutes(fastify) {
             if (!filePath) {
                 return reply.code(400).send({ detail: 'path query parameter is required' });
             }
-            const status = fs_service_1.fsService.getAgentPermissionStatus(filePath);
+            const status = await fs_service_1.fsService.getAgentPermissionStatusAsync(filePath);
             return reply.send({
                 notebook_path: filePath,
                 ...status,
@@ -338,4 +345,31 @@ async function notebookRoutes(fastify) {
             return reply.code(500).send({ detail: message });
         }
     });
+    /**
+     * Persist live ipywidgets state into notebook metadata.widgets
+     * (application/vnd.jupyter.widget-state+json), making saved notebooks
+     * render static widgets in Jupyter/nbviewer.
+     */
+    fastify.post('/notebook/widget-state', async (request, reply) => {
+        try {
+            const { path: filePath, widget_state } = request.body;
+            if (!filePath) {
+                return reply.code(400).send({ detail: 'path is required' });
+            }
+            if (!widget_state || typeof widget_state !== 'object') {
+                return reply.code(400).send({ detail: 'widget_state must be an object' });
+            }
+            const updateResult = await fs_service_1.fsService.updateNotebookMetadata(filePath, {
+                widgets: { 'application/vnd.jupyter.widget-state+json': widget_state },
+            });
+            if (!updateResult.success) {
+                return reply.code(500).send({ detail: updateResult.error || 'Failed to update notebook metadata' });
+            }
+            return reply.send({ status: 'ok', notebook_path: filePath, mtime: updateResult.mtime });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : 'Unknown error';
+            return reply.code(500).send({ detail: message });
+        }
+    });
 }

package/node-server/dist/routes/python.d.ts

@@ -2,7 +2,6 @@
  * Python Discovery API Routes
  */
 import { FastifyInstance } from 'fastify';
-import { PythonDiscoveryService } from '../discovery/discovery-service';
-declare const discoveryService: PythonDiscoveryService;
+declare const discoveryService: import("../discovery/discovery-service").PythonDiscoveryService;
 export default function pythonRoutes(fastify: FastifyInstance): Promise<void>;
 export { discoveryService };

package/node-server/dist/routes/python.js

@@ -11,7 +11,10 @@ const kernelspec_1 = require("../kernel/kernelspec");
 const default_kernel_1 = require("../kernel/default-kernel");
 const server_registry_1 = require("../cluster/server-registry");
 const kernel_1 = require("./kernel");
-const discoveryService = new discovery_service_1.PythonDiscoveryService();
+// The shared singleton — kernel-service preflight/labels and per-env
+// kernelspec scanning read its in-memory cache, so routes must write through
+// the SAME instance (a second instance would leave the singleton stale).
+const discoveryService = discovery_service_1.pythonDiscovery;
 exports.discoveryService = discoveryService;
 async function pythonRoutes(fastify) {
     /**
@@ -41,6 +44,9 @@ async function pythonRoutes(fastify) {
                 const data = await response.json();
                 return reply.send(data);
             }
+            // Discover Python environments FIRST: kernelspec discovery also scans
+            // each known env's share/jupyter/kernels, so it must see the fresh list.
+            const environments = await discoveryService.discover({ forceRefresh: refresh });
             // Get Jupyter kernelspecs and transform to snake_case
             const kernelspecs = (0, kernelspec_1.discoverKernelSpecs)(refresh).map(k => ({
                 name: k.name,
@@ -50,8 +56,6 @@ async function pythonRoutes(fastify) {
                 python_path: k.argv?.[0] || null, // First element of argv is typically the Python executable
             }));
             const kernelspecNames = new Set(kernelspecs.map(k => k.name));
-            // Get discovered Python environments
-            const environments = await discoveryService.discover({ forceRefresh: refresh });
             // Convert to snake_case and match with kernelspecs
             const envObjects = environments.map(env => ({
                 path: env.path,
@@ -75,6 +79,138 @@ async function pythonRoutes(fastify) {
             return reply.code(500).send({ detail: message });
         }
     });
+    /**
+     * Install ipykernel into an environment (no kernelspec registration — env
+     * kernels raw-launch). One installer chosen up front (conda → uv → pip).
+     *
+     * Responds with an NDJSON stream so the UI can show installer output LIVE:
+     *   {"type":"output","data":"…"}    — stdout/stderr chunks as they arrive
+     *   {"type":"done","installer":…}   — success terminator
+     *   {"type":"error","detail":…,"code":…,"install_hint":…} — failure terminator
+     * Pre-stream validation failures are plain JSON error responses.
+     */
+    fastify.post('/python/install-ipykernel', async (request, reply) => {
+        const { python_path, server_id } = request.body;
+        if (!python_path) {
+            return reply.code(400).send({ detail: 'python_path is required' });
+        }
+        const localServerId = server_registry_1.serverRegistry.getLocalServerId();
+        if (server_id && server_id !== localServerId && server_id !== 'local') {
+            const server = server_registry_1.serverRegistry.getServer(server_id);
+            if (!server) {
+                return reply.code(404).send({ detail: `Server not found: ${server_id}` });
+            }
+            if (server.status !== 'online') {
+                return reply.code(503).send({ detail: `Server is offline: ${server_id}` });
+            }
+            const response = await fetch(`${server.url}/api/python/install-ipykernel`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    ...(process.env.NEBULA_CLUSTER_SECRET ? { 'X-Nebula-Cluster-Secret': process.env.NEBULA_CLUSTER_SECRET } : {}),
+                },
+                body: JSON.stringify({ python_path }),
+            });
+            if (!response.ok || !response.body) {
+                const error = await response.json().catch(() => ({ detail: 'Unknown error' }));
+                return reply.code(response.status).send({
+                    detail: error.detail || 'Failed to install ipykernel',
+                    code: error.code,
+                    install_hint: error.install_hint,
+                });
+            }
+            // Pipe the remote NDJSON stream through untouched.
+            reply.hijack();
+            reply.raw.writeHead(200, { 'Content-Type': 'application/x-ndjson', 'Cache-Control': 'no-cache' });
+            try {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                for await (const chunk of response.body) {
+                    reply.raw.write(chunk);
+                }
+            }
+            catch { /* upstream died — terminate what we have */ }
+            reply.raw.end();
+            return reply;
+        }
+        // Local install: stream output as it happens, then a terminator event.
+        reply.hijack();
+        reply.raw.writeHead(200, { 'Content-Type': 'application/x-ndjson', 'Cache-Control': 'no-cache' });
+        const send = (obj) => reply.raw.write(`${JSON.stringify(obj)}\n`);
+        try {
+            const result = await discoveryService.installIpykernel(python_path, (chunk) => send({ type: 'output', data: chunk }));
+            send({ type: 'done', installer: result.installer, message: result.message, python_path });
+        }
+        catch (err) {
+            if (err instanceof types_1.KernelProvisionError) {
+                send({ type: 'error', detail: err.message, code: err.code, install_hint: err.installHint });
+            }
+            else {
+                send({ type: 'error', detail: err instanceof Error ? err.message : 'Unknown error' });
+            }
+        }
+        reply.raw.end();
+        return reply;
+    });
+    /**
+     * Probe a manually-entered interpreter path ("Enter interpreter path…"):
+     * validate it runs, classify + enrich it, persist it into the discovery
+     * cache, and return it in the same snake_case shape as /python/environments.
+     */
+    fastify.post('/python/probe', async (request, reply) => {
+        try {
+            const { python_path, server_id } = request.body;
+            if (!python_path) {
+                return reply.code(400).send({ detail: 'python_path is required' });
+            }
+            const localServerId = server_registry_1.serverRegistry.getLocalServerId();
+            if (server_id && server_id !== localServerId && server_id !== 'local') {
+                const server = server_registry_1.serverRegistry.getServer(server_id);
+                if (!server) {
+                    return reply.code(404).send({ detail: `Server not found: ${server_id}` });
+                }
+                if (server.status !== 'online') {
+                    return reply.code(503).send({ detail: `Server is offline: ${server_id}` });
+                }
+                const response = await fetch(`${server.url}/api/python/probe`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        ...(process.env.NEBULA_CLUSTER_SECRET ? { 'X-Nebula-Cluster-Secret': process.env.NEBULA_CLUSTER_SECRET } : {}),
+                    },
+                    body: JSON.stringify({ python_path }),
+                });
+                if (!response.ok) {
+                    const error = await response.json().catch(() => ({ detail: 'Unknown error' }));
+                    return reply.code(response.status).send({
+                        detail: error.detail || 'Failed to probe interpreter',
+                        code: error.code,
+                        install_hint: error.install_hint,
+                    });
+                }
+                return reply.send(await response.json());
+            }
+            const env = await discoveryService.probeAndRemember(python_path);
+            return reply.send({
+                path: env.path,
+                version: env.version,
+                display_name: env.displayName,
+                env_type: env.envType,
+                env_name: env.envName,
+                has_ipykernel: env.hasIpykernel,
+                externally_managed: env.externallyManaged,
+                install_hint: env.installHint,
+                kernel_name: env.kernelName,
+            });
+        }
+        catch (err) {
+            if (err instanceof types_1.KernelProvisionError) {
+                const status = err.code === 'python_not_found' ? 404 : 500;
+                return reply.code(status).send({ detail: err.message, code: err.code, install_hint: err.installHint });
+            }
+            const message = err instanceof Error ? err.message : 'Unknown error';
+            return reply.code(500).send({ detail: message });
+        }
+    });
     /**
      * Install ipykernel and register a Python environment as a Jupyter kernel
      */

package/node-server/dist/scheduler/allocation-service.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Allocation service — owns the lifecycle a compute allocation has *before* and
+ * *around* the cluster registry: submit a job, follow it through the queue, and
+ * correlate the client-server's registration (by one-time token) back to the
+ * allocation. Once correlated, the allocation is a normal registered server and
+ * kernels run on it through the existing cluster path.
+ *
+ * Phase-1 MVP: in-memory allocations, direct transport (no SSH tunnel — not
+ * needed where compute↔login is directly reachable).
+ */
+import type { Scheduler, JobSpec } from './types';
+import { type LaunchContext } from './job-template';
+export type AllocationState = 'pending' | 'running' | 'active' | 'ended' | 'failed' | 'cancelled';
+export interface Allocation {
+    id: string;
+    jobId?: string;
+    token: string;
+    spec: JobSpec;
+    state: AllocationState;
+    serverId?: string;
+    nodes?: string[];
+    reason?: string;
+    createdAt: number;
+    walltimeEndsAt?: number;
+}
+declare class AllocationService {
+    private scheduler;
+    private ctx;
+    private allocations;
+    private pollTimer;
+    private enabled;
+    private lastPollAt;
+    private lostListenerRegistered;
+    init(scheduler: Scheduler, ctx: LaunchContext): void;
+    /** Poll immediately (debounced to 2s so error bursts don't hammer squeue). */
+    pollNow(): void;
+    private stateFile;
+    /**
+     * Allocations survive head-server restarts: persisted on every change,
+     * reloaded on init. A reloaded 'active' allocation is demoted to 'running'
+     * with its serverId cleared — the registry is empty after a restart, and
+     * the compute node's client-server re-registers itself (heartbeat -> 404
+     * -> re-register with its allocation token) within ~30s, at which point
+     * poll() re-correlates and promotes it back to 'active'. The SLURM job
+     * itself is re-checked by jobId on the next poll, so jobs that died while
+     * we were down are marked ended/failed instead of lingering.
+     */
+    private persist;
+    private loadPersisted;
+    /** Pick the poll cadence from what we're actually waiting for. */
+    private nextPollDelay;
+    private scheduleNextPoll;
+    isEnabled(): boolean;
+    getScheduler(): Scheduler | null;
+    list(): Allocation[];
+    get(id: string): Allocation | undefined;
+    create(spec: JobSpec): Promise<Allocation>;
+    cancel(id: string): Promise<boolean>;
+    private poll;
+    shutdown(): void;
+}
+export declare const allocationService: AllocationService;
+export {};