@nimbus-sh/worker 0.6.0 → 0.8.0

package/dist/hosted/runtime.d.ts

@@ -0,0 +1,114 @@
+import type { NimbusWorkspace } from '@nimbus-sh/core/workspace';
+import type { PortRegistry } from '@nimbus-sh/core/runtime/port-registry.js';
+import type { ProcessLogReadOptions } from '@nimbus-sh/core/runtime/process-logs.js';
+import type { VfsCred } from '@nimbus-sh/core/runtime/os-contracts.js';
+import type { SandboxFs } from '@nimbus-sh/core/substrate/lifo/sandbox/types.js';
+import { type SupervisorOpEnvelope } from '@nimbus-sh/core/workspace/supervisor-op.js';
+import { WebSocketTerminal } from '../facets/ws-terminal.js';
+import * as operations from '../session/programmatic.js';
+import * as services from './services.js';
+import { z } from 'zod/v4';
+declare const HostedTask: z.ZodEnum<{
+    "resident-launch": "resident-launch";
+    "log-flush": "log-flush";
+    "log-janitor": "log-janitor";
+}>;
+export type HostedRuntimeTask = z.infer<typeof HostedTask>;
+export interface HostedRuntimeLifecycle {
+    waitUntil(task: Promise<void>): void;
+    schedule(reason: HostedRuntimeTask, at: number): Promise<void>;
+    cancel(reason: HostedRuntimeTask): Promise<void>;
+}
+export interface HostedRuntimeOptions {
+    workspace: NimbusWorkspace;
+    ctx: DurableObjectState;
+    env: services.HostedRuntimeEnv;
+    ports: PortRegistry;
+    lifecycle: HostedRuntimeLifecycle;
+    basePath?: string;
+    origin?: string;
+}
+export interface RuntimeFiles extends SandboxFs {
+    as(cred: VfsCred): RuntimeFiles;
+}
+export declare function composeHostedRuntime(options: HostedRuntimeOptions): Promise<{
+    workspace: NimbusWorkspace;
+    terminal: WebSocketTerminal;
+    files: RuntimeFiles;
+    runtimes: import("@nimbus-sh/core/runtime/runtime-manager.js").RuntimeManager;
+    ready: (options?: operations.ProgrammaticReadyOptions | undefined) => Promise<{
+        ok: true;
+        preinstalled: string[];
+    }>;
+    exec: (command: string, options?: operations.ProgrammaticExecOptions | undefined) => Promise<operations.ProgrammaticExecResult>;
+    runCode: (code: string, options?: (operations.ProgrammaticExecOptions & {
+        language?: "javascript" | "typescript" | "python" | "ruby" | "shell";
+        install?: "never" | "ifMissing";
+    }) | undefined) => Promise<operations.ProgrammaticExecResult>;
+    startProcess: (command: string, options?: operations.ProgrammaticExecOptions | undefined) => Promise<operations.ProgrammaticStartResult>;
+    listProcesses: () => Promise<operations.SerializedProcess[]>;
+    killProcess: (pid: number) => Promise<{
+        ok: boolean;
+        pid: number;
+    }>;
+    writeProcessInput: (pid: number, data: string) => Promise<{
+        ok: boolean;
+        pid: number;
+    }>;
+    endProcessInput: (pid: number) => Promise<{
+        ok: boolean;
+        pid: number;
+    }>;
+    resizeProcess: (pid: number, size: {
+        columns: number;
+        rows: number;
+    }) => Promise<{
+        ok: boolean;
+        pid: number;
+    }>;
+    signalProcess: (pid: number, signal: string) => Promise<{
+        ok: boolean;
+        pid: number;
+    }>;
+    processLogs: (pid: number, options?: ProcessLogReadOptions) => Promise<{
+        pid: number;
+        chunks: import("@nimbus-sh/core/runtime/process-logs.js").SequencedLogChunk[];
+        text: string;
+        cursor: number;
+        truncated: boolean;
+        exit: import("@nimbus-sh/core/runtime/process-logs.js").ProcessExitInfo | null;
+    }>;
+    listPorts: () => Promise<operations.SerializedPort[]>;
+    listApps: () => Promise<operations.ListedApp[]>;
+    exposeApp: (target: operations.AppTarget, options?: {
+        visibility?: "scoped" | "public";
+        name?: string;
+    } | undefined) => Promise<operations.ExposedAppResult>;
+    removeApp: (target: operations.AppTarget) => Promise<{
+        owner: string;
+        removed: boolean;
+        port: number | null;
+    }>;
+    rotateLink: (target: operations.AppTarget) => Promise<operations.ExposedAppResult>;
+    installRuntime: (spec: string, options?: {
+        force?: boolean;
+    } | undefined) => Promise<import("../runtime/package-manager.js").RuntimeInstallSummary>;
+    ensureRuntimes: (specs: string[], options?: {
+        force?: boolean;
+    } | undefined) => Promise<import("../runtime/package-manager.js").RuntimeInstallSummary[]>;
+    listRuntimes: () => Promise<{
+        installed: import("@nimbus-sh/core/runtime/installed-runtimes.js").RuntimeSummary[];
+        available: import("@nimbus-sh/core/runtime/runtime-package.js").RuntimeAvailability[];
+    }>;
+    spawnWorker: (workerCode: string, command: string, cwd: string, opts?: import("../facets/manager.js").LongRunningWorkerSpawnOptions | undefined) => Promise<import("../facets/manager.js").SpawnedWorker>;
+    routeCapabilityPort: (port: number, capability: string, request: Request<unknown, CfProperties<unknown>>, pathname: string) => Promise<Response>;
+    supervisorOp: (envelope: SupervisorOpEnvelope) => Promise<unknown>;
+    onScheduled: (task: HostedRuntimeTask) => Promise<void>;
+    attachTerminal: (ws: WebSocket) => Promise<void>;
+    terminalFrame: (ws: WebSocket, message: string | ArrayBuffer) => Promise<void>;
+    terminalClose: (ws: WebSocket) => void;
+    close: () => Promise<void>;
+}>;
+export type HostedRuntime = Awaited<ReturnType<typeof composeHostedRuntime>>;
+export {};
+//# sourceMappingURL=runtime.d.ts.map

package/dist/hosted/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../src/hosted/runtime.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAEjE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0CAA0C,CAAC;AAC7E,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,yCAAyC,CAAC;AACrF,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yCAAyC,CAAC;AAGvE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iDAAiD,CAAC;AACjF,OAAO,EAAwB,KAAK,oBAAoB,EAAE,MAAM,4CAA4C,CAAC;AAW7G,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAO7D,OAAO,KAAK,UAAU,MAAM,4BAA4B,CAAC;AACzD,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAC;AAE1C,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAI3B,QAAA,MAAM,UAAU;;;;EAA0D,CAAC;AAC3E,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAE3D,MAAM,WAAW,sBAAsB;IACrC,SAAS,CAAC,IAAI,EAAE,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IACrC,QAAQ,CAAC,MAAM,EAAE,iBAAiB,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/D,MAAM,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAClD;AAED,MAAM,WAAW,oBAAoB;IACnC,SAAS,EAAE,eAAe,CAAC;IAC3B,GAAG,EAAE,kBAAkB,CAAC;IACxB,GAAG,EAAE,QAAQ,CAAC,gBAAgB,CAAC;IAC/B,KAAK,EAAE,YAAY,CAAC;IACpB,SAAS,EAAE,sBAAsB,CAAC;IAClC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,YAAa,SAAQ,SAAS;IAC7C,EAAE,CAAC,IAAI,EAAE,OAAO,GAAG,YAAY,CAAC;CACjC;AAsOD,wBAAsB,oBAAoB,CAAC,OAAO,EAAE,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAkBjD,MAAM,YAAY,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAWjC,oBAAoB;wBACzB,iBAAiB;yBAChB,SAAS;wBACV,SAAS,WAAW,MAAM,GAAG,WAAW;wBACxC,SAAS;;GAGhC;AAED,MAAM,MAAM,aAAa,GAAG,OAAO,CAAC,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAC,CAAC"}

package/dist/hosted/runtime.js

@@ -0,0 +1,288 @@
+import { requireVfsCred } from '@nimbus-sh/core/runtime/os-contracts.js';
+import { SandboxFsImpl } from '@nimbus-sh/core/substrate/lifo/sandbox/SandboxFs.js';
+import { SUPERVISOR_OP_ROUTES } from '@nimbus-sh/core/workspace/supervisor-op.js';
+import { WebSocketTerminal } from '../facets/ws-terminal.js';
+import { buildSessionSupervisorOps } from '../session/supervisor-op.js';
+import { installLogPersistence } from '../session/hibernation.js';
+import { appendScrollback, ensureSessionStateSchema, loadScrollback, loadShellState, persistShellState } from '../session/state-store.js';
+import { wireProcessLogSocketBroadcast } from '../runtime/process-logs-api.js';
+import { routeRuntimeLoopback } from '../session/loopback.js';
+import * as rpc from '../session/rpc.js';
+import * as operations from '../session/programmatic.js';
+import * as services from './services.js';
+import { registerHostedCommands } from './commands.js';
+import { z } from 'zod/v4';
+import { adoptCtxExports, supervisorEntrypoint } from '@nimbus-sh/fabric/composition.js';
+import { hostNamespaceBinding } from '@nimbus-sh/fabric/host-dispatch.js';
+const HostedTask = z.enum(['resident-launch', 'log-flush', 'log-janitor']);
+const InputFrame = z.discriminatedUnion('type', [
+    z.object({ type: z.literal('input'), data: z.string() }),
+    z.object({ type: z.literal('resize'), cols: z.number().int().positive(), rows: z.number().int().positive() }),
+]);
+class RuntimeOwner {
+    options;
+    terminal;
+    _cpRegistry;
+    _programmaticShellQueues = new Map();
+    _hostedProcesses = new Map();
+    _hostedProcessWaiters = new Map();
+    _cirrusHmrWsClients = new Map();
+    closing = null;
+    _w9PersistWired = false;
+    _w9SchemaInit = false;
+    _viteShimPid = null;
+    _viteShimPort = null;
+    wranglerAliasBannerShown = false;
+    facetManagerComposed = null;
+    facetProcessManager = null;
+    esbuildService = null;
+    bundlePool = null;
+    npmInstaller = null;
+    fetchProxyEntrypoint = null;
+    viteDevServer = null;
+    cirrusReal = null;
+    nimbusWrangler = null;
+    webSocketRelay = null;
+    readyPromise = null;
+    supervisor = null;
+    flushScheduled = false;
+    janitorScheduled = false;
+    recoveryNotice = false;
+    services;
+    constructor(options) {
+        this.options = options;
+        hostNamespaceBinding(options.env, 'HostedRuntime');
+        const exports = Reflect.get(options.ctx, 'exports');
+        if (!supervisorEntrypoint(exports)) {
+            throw new Error('Export the configured supervisor entrypoint and call composeFabric before composing a hosted runtime');
+        }
+        adoptCtxExports(exports);
+        ensureSessionStateSchema(options.ctx);
+        this.terminal = new WebSocketTerminal(null, (data) => {
+            appendScrollback(options.ctx, data, Date.now());
+            persistShellState(options.ctx, { cwd: this.shell.getCwd(), env: this.shell.getEnv() });
+        });
+        this._cpRegistry = options.workspace.registry;
+        this.services = services.bindRuntimeServices(this, {
+            ctx: options.ctx,
+            env: options.env,
+            notify: (line) => this._notifySession(line),
+            requestLaunchTurn: (at) => this._scheduleLaunchTurn(at),
+        });
+        options.workspace.shell.bindTerminal(this.terminal);
+        installLogPersistence(this, options.ctx, () => this.scheduleLogs());
+        wireProcessLogSocketBroadcast(this.processes, options.ctx);
+    }
+    get ctx() { return this.options.ctx; }
+    get _w1SessionDestroyed() { return this.closing !== null; }
+    get env() { return this.options.env; }
+    get sqliteFs() { return this.options.workspace.vfs; }
+    get kernel() { return this.options.workspace.kernel; }
+    get shell() { return this.options.workspace.shell; }
+    get shellProcessPid() { return this.options.workspace.shellProcessPid; }
+    get runtimeManager() { return this.options.workspace.runtimes; }
+    get processes() { return this.options.workspace.processes; }
+    get portRegistry() { return this.options.ports; }
+    get facetManager() { return this.facetManagerComposed?.manager ?? null; }
+    get sessionBasePath() { return this.options.basePath ?? ''; }
+    get sessionOrigin() { return this.options.origin ?? ''; }
+    get viteBasePath() { return `${this.sessionBasePath}/preview`; }
+    get nimbusDebug() { return Reflect.get(this.env, 'NIMBUS_DEBUG') === '1'; }
+    assertOpen() {
+        if (this._w1SessionDestroyed)
+            throw new Error('Nimbus runtime is closed');
+    }
+    ensureRuntimeReady() {
+        this.assertOpen();
+        this.readyPromise ??= (async () => {
+            const saved = loadShellState(this.ctx);
+            this.recoveryNotice = saved.hasPersistedState;
+            if (saved.cwd)
+                this.shell.setCwd(saved.cwd);
+            if (saved.env)
+                Object.assign(this.shell.getEnv(), saved.env);
+            await registerHostedCommands(this, this.options.workspace);
+            await this.options.workspace.start();
+        })();
+        return this.readyPromise;
+    }
+    ensureSqliteFs() { return this.sqliteFs; }
+    routeLoopback(port, request) { return routeRuntimeLoopback(this.portRegistry, port, request); }
+    ensureBundlePool() { this.assertOpen(); return this.services.ensureBundlePool(); }
+    ensureFacetManager() { this.assertOpen(); return this.services.ensureFacetManager(); }
+    ensureFetchProxy(log) { return this.services.ensureFetchProxy(log); }
+    buildFetchFn(log) { return this.services.buildFetchFn(log); }
+    ensureNpmInstaller(onProgress) { this.assertOpen(); return this.services.ensureNpmInstaller(onProgress); }
+    ensureGlobalPrefixDirs(prefix) { return this.services.ensureGlobalPrefixDirs(prefix); }
+    _envFlagDefaultOn(name) { return this.services._envFlagDefaultOn(name); }
+    _ensureFacetProcessManager() { this.assertOpen(); return this.services._ensureFacetProcessManager(); }
+    _ensureWebSocketRelay() { this.assertOpen(); return this.services._ensureWebSocketRelay(); }
+    _setCpRegistry(registry) {
+        if (registry !== this._cpRegistry)
+            throw new Error('Nimbus runtime cannot replace the workspace registry');
+    }
+    _notifySession(line) { this.terminal.write(`${line}\r\n`); }
+    async _scheduleLaunchTurn(notBefore = Date.now()) {
+        await this.options.lifecycle.schedule('resident-launch', Math.max(Date.now(), notBefore));
+        return true;
+    }
+    _reportExternalExit(pid, code, reason) { return rpc._reportExternalExit(this, pid, code, reason); }
+    _emitExitDump(pid, code) { return rpc._emitExitDump(this, pid, code); }
+    _emitShellExecDone(pid, command, code, duration) { return rpc._emitShellExecDone(this, pid, command, code, duration); }
+    _rpcStdout(pid, data) { return rpc._rpcStdout(this, pid, data); }
+    _rpcStderr(pid, data) { return rpc._rpcStderr(this, pid, data); }
+    supervisorOps() {
+        this.supervisor ??= buildSessionSupervisorOps(this, undefined, Object.fromEntries(Object.values(SUPERVISOR_OP_ROUTES).map(({ method }) => {
+            const handler = Reflect.get(rpc, method);
+            if (typeof handler !== 'function')
+                throw new Error(`Missing Nimbus supervisor implementation: ${method}`);
+            return [method, (...args) => Reflect.apply(handler, undefined, [this, ...args])];
+        })));
+        return this.supervisor;
+    }
+    supervisorOp(envelope) {
+        this.assertOpen();
+        return this.supervisorOps().dispatch(envelope);
+    }
+    supervisorBridge(pid) { return this.supervisorOps().bridge(pid); }
+    supervisorForgetBridge(pid) { this.supervisorOps().forget(pid); }
+    scheduleLogs() {
+        if (this._w1SessionDestroyed)
+            return;
+        if (!this.flushScheduled) {
+            this.flushScheduled = true;
+            this.options.lifecycle.waitUntil(this.options.lifecycle.schedule('log-flush', Date.now() + 250));
+        }
+        if (!this.janitorScheduled) {
+            this.janitorScheduled = true;
+            this.options.lifecycle.waitUntil(this.options.lifecycle.schedule('log-janitor', Date.now() + 60_000));
+        }
+    }
+    async onScheduled(task) {
+        if (this._w1SessionDestroyed)
+            return;
+        if (task === 'resident-launch') {
+            await this.ensureFacetManager().pumpLaunches();
+        }
+        else if (task === 'log-flush') {
+            this.flushScheduled = false;
+            this.processes.flushLogs();
+        }
+        else {
+            this.janitorScheduled = false;
+            this.processes.dropLogsOlderThan(undefined, (pid) => !this.processes.get(pid));
+            if (this.processes.stats.running > 0 || this.processes.logStats.totalPids > 0)
+                this.scheduleLogs();
+        }
+    }
+    async attachTerminal(ws, resume = 'reconnect') {
+        await this.ensureRuntimeReady();
+        if (this.terminal.ws === ws)
+            return;
+        this.terminal.attach(ws);
+        if (resume === 'reconnect')
+            this.terminal.write(loadScrollback(this.ctx));
+        if (this.recoveryNotice) {
+            this.terminal.write('\r\n[Runtime resumed; files and shell settings restored. Previous interpreter state was not retained.]\r\n');
+            this.recoveryNotice = false;
+        }
+        if (!this.shell.running)
+            this.shell.printPrompt();
+        this.terminal.flushNow();
+        ws.send(JSON.stringify({ type: 'ready' }));
+    }
+    async terminalFrame(ws, frame) {
+        await this.attachTerminal(ws, 'wake');
+        const text = typeof frame === 'string' ? frame : new TextDecoder().decode(frame);
+        const input = InputFrame.parse(JSON.parse(text));
+        this.terminal.handleMessage(input);
+        persistShellState(this.ctx, { cwd: this.shell.getCwd(), env: this.shell.getEnv() });
+    }
+    terminalClose(ws) {
+        if (this.terminal.ws !== ws)
+            return;
+        this.terminal.flushNow();
+        persistShellState(this.ctx, { cwd: this.shell.getCwd(), env: this.shell.getEnv() });
+        this.terminal.detach();
+        this.processes.flushLogs();
+    }
+    close() {
+        this.closing ??= Promise.resolve().then(async () => {
+            const failures = [];
+            const clean = async (action) => {
+                try {
+                    await action();
+                }
+                catch (error) {
+                    failures.push(error instanceof Error ? error : new Error(String(error)));
+                }
+            };
+            await clean(() => this.terminal.disposeRepl());
+            await clean(() => this.terminal.sendData('\x03'));
+            for (const process of this.processes.getAll()) {
+                await clean(() => this.webSocketRelay?.closeForPid(process.pid));
+                if (process.state !== 'running')
+                    continue;
+                await clean(() => { if (!this.facetManager?.kill(process.pid))
+                    this.processes.kill(process.pid); });
+                await clean(() => { this.portRegistry.unregisterByPid(process.pid); });
+            }
+            await clean(() => this.viteDevServer?.stop());
+            await clean(() => this.cirrusReal?.stop(this.ctx));
+            await clean(() => this.nimbusWrangler?.stop());
+            await clean(() => this.bundlePool?.dispose());
+            await clean(() => this.processes.flushLogs());
+            this.terminal.flushNow();
+            this.terminal.close();
+            for (const ws of this.ctx.getWebSockets('process-logs')) {
+                await clean(() => ws.close(1000, 'runtime closed'));
+            }
+            for (const task of HostedTask.options)
+                await clean(() => this.options.lifecycle.cancel(task));
+            if (failures.length > 0)
+                throw new AggregateError(failures, 'Nimbus runtime cleanup failed');
+        });
+        return this.closing;
+    }
+}
+function runtimeFiles(workspace, cred) {
+    const view = new SandboxFsImpl(workspace.kernel.vfs.as(cred), () => workspace.shell.getCwd());
+    return Object.assign(view, { as: (next) => runtimeFiles(workspace, requireVfsCred(next, 'runtime files')) });
+}
+export async function composeHostedRuntime(options) {
+    const owner = new RuntimeOwner(options);
+    await owner.ensureRuntimeReady();
+    return {
+        workspace: options.workspace,
+        terminal: owner.terminal,
+        files: runtimeFiles(options.workspace, owner.processes.cred(owner.shellProcessPid)),
+        runtimes: owner.runtimeManager,
+        ready: operations.ensureProgrammaticReady.bind(null, owner),
+        exec: operations.rpcExec.bind(null, owner),
+        runCode: operations.rpcRunCode.bind(null, owner),
+        startProcess: operations.rpcStartProcess.bind(null, owner),
+        listProcesses: operations.rpcListProcesses.bind(null, owner),
+        killProcess: operations.rpcKillProcess.bind(null, owner),
+        writeProcessInput: operations.rpcWriteProcessInput.bind(null, owner),
+        endProcessInput: operations.rpcEndProcessInput.bind(null, owner),
+        resizeProcess: operations.rpcResizeProcess.bind(null, owner),
+        signalProcess: operations.rpcSignalProcess.bind(null, owner),
+        processLogs: (pid, options) => operations.rpcProcessLogs(owner, pid, options),
+        listPorts: operations.rpcListPorts.bind(null, owner),
+        listApps: operations.rpcListApps.bind(null, owner),
+        exposeApp: operations.rpcExposeApp.bind(null, owner),
+        removeApp: operations.rpcRemoveApp.bind(null, owner),
+        rotateLink: operations.rpcRotateLink.bind(null, owner),
+        installRuntime: operations.rpcInstallRuntime.bind(null, owner),
+        ensureRuntimes: operations.rpcEnsureRuntimes.bind(null, owner),
+        listRuntimes: operations.rpcListRuntimes.bind(null, owner),
+        spawnWorker: operations.rpcSpawnWorker.bind(null, owner),
+        routeCapabilityPort: operations.rpcRouteCapabilityPort.bind(null, owner),
+        supervisorOp: (envelope) => owner.supervisorOp(envelope),
+        onScheduled: (task) => owner.onScheduled(task),
+        attachTerminal: (ws) => owner.attachTerminal(ws),
+        terminalFrame: (ws, message) => owner.terminalFrame(ws, message),
+        terminalClose: (ws) => owner.terminalClose(ws),
+        close: () => owner.close(),
+    };
+}

package/dist/hosted/services.d.ts

@@ -0,0 +1,40 @@
+import { type ComposedFacetManager } from "../facets/compose.js";
+import { EsbuildBundlePool } from "../facets/esbuild-bundle-pool.js";
+import type { NpmInstaller } from "../npm/installer.js";
+import { WebSocketRelay } from "../session/ws-relay.js";
+import type { SessionInternal } from '../session/internal.js';
+import type { RuntimeCatalogEnv } from '../runtime/runtime-catalog.js';
+import type { IsolatePoolEnv } from '@nimbus-sh/fabric/isolate-pool.js';
+export interface HostedRuntimeEnv extends RuntimeCatalogEnv, IsolatePoolEnv {
+    ASSETS?: Fetcher;
+}
+export type RuntimeServiceHost = Pick<SessionInternal, '_cpRegistry' | '_envFlagDefaultOn' | '_reportExternalExit' | 'buildFetchFn' | 'bundlePool' | 'ensureBundlePool' | 'ensureFacetManager' | 'ensureFetchProxy' | 'ensureSqliteFs' | 'esbuildService' | 'facetManagerComposed' | 'facetProcessManager' | 'fetchProxyEntrypoint' | 'npmInstaller' | 'portRegistry' | 'processes' | 'shell' | 'sqliteFs' | 'terminal'> & {
+    webSocketRelay: WebSocketRelay | null;
+};
+export interface RuntimeServiceContext {
+    readonly ctx: DurableObjectState;
+    readonly env: HostedRuntimeEnv;
+    notify(line: string): void;
+    requestLaunchTurn(notBefore?: number): Promise<boolean>;
+}
+export declare function ensureBundlePool(self: RuntimeServiceHost, runtimeContext: RuntimeServiceContext): EsbuildBundlePool;
+export declare function ensureFacetManager(self: RuntimeServiceHost, runtimeContext: RuntimeServiceContext): ComposedFacetManager;
+export declare function _ensureWebSocketRelay(self: RuntimeServiceHost, runtimeContext: RuntimeServiceContext): WebSocketRelay;
+export declare function _ensureFacetProcessManager(self: RuntimeServiceHost, runtimeContext: RuntimeServiceContext): any;
+export declare function ensureFetchProxy(self: RuntimeServiceHost, runtimeContext: RuntimeServiceContext, log?: (msg: string) => void): any | null;
+export declare function buildFetchFn(self: RuntimeServiceHost, runtimeContext: RuntimeServiceContext, log?: (msg: string) => void): ((url: string, init?: RequestInit) => Promise<Response>) | undefined;
+export declare function ensureNpmInstaller(self: RuntimeServiceHost, runtimeContext: RuntimeServiceContext, onProgress?: (msg: string) => void): Promise<NpmInstaller>;
+export declare function _envFlagDefaultOn(self: RuntimeServiceHost, runtimeContext: RuntimeServiceContext, name: string): boolean;
+export declare function ensureGlobalPrefixDirs(self: RuntimeServiceHost, runtimeContext: RuntimeServiceContext, prefix: string): void;
+export declare function bindRuntimeServices(host: RuntimeServiceHost, context: RuntimeServiceContext): {
+    ensureBundlePool: () => EsbuildBundlePool;
+    ensureFacetManager: () => ComposedFacetManager;
+    _ensureWebSocketRelay: () => WebSocketRelay;
+    _ensureFacetProcessManager: () => any;
+    ensureFetchProxy: (log?: ((msg: string) => void) | undefined) => any;
+    buildFetchFn: (log?: ((msg: string) => void) | undefined) => ((url: string, init?: RequestInit) => Promise<Response>) | undefined;
+    ensureNpmInstaller: (onProgress?: ((msg: string) => void) | undefined) => Promise<NpmInstaller>;
+    _envFlagDefaultOn: (name: string) => boolean;
+    ensureGlobalPrefixDirs: (prefix: string) => void;
+};
+//# sourceMappingURL=services.d.ts.map

package/dist/hosted/services.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"services.d.ts","sourceRoot":"","sources":["../../src/hosted/services.ts"],"names":[],"mappings":"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"}