@bkm016/calcite 0.2.0 → 0.5.0

package/dist/client-core.js

@@ -1,43 +1,25 @@
-import { randomBytes } from 'node:crypto';
 import { EventEmitter } from 'node:events';
-import { mkdir, rm, writeFile } from 'node:fs/promises';
-import { Socket } from 'node:net';
 import { join } from 'node:path';
 import { prepareAccount, syncAccount } from './accounts.js';
-import { acquireDisplay, which } from './display.js';
-import { hmcListEntry, hmcQuote, hmcVersionArgs, killTree, runHmc, writeHmcProfile } from './hmc.js';
-import { installProbe, prepareGame } from './install.js';
+import { which } from './display.js';
+import { Feed } from './feed.js';
+import { GameRun } from './game-run.js';
+import { killTree, runHmc, writeHmcProfile } from './hmc.js';
+import { assetsVerified, installProbe, markAssetsVerified, prepareGame } from './install.js';
+import { BackendWatch, gameJvmArgs, hmcLaunchCommand, hmcProperties, joinArgs, noBackendHint, reconnectDelay, reconnectLimit, waitForServer, } from './launch.js';
 import { parseLoader } from './loaders.js';
 import { acquireLock } from './lock.js';
 import { logger } from './log.js';
-import { resolveMods, syncMods } from './mods.js';
-import { javaProxyProps } from './net.js';
+import { resolveExtensions, resolveMods, syncMods } from './mods.js';
 import { supportsQuickPlay } from './mojang.js';
 import { defaultOptions, writeOptions } from './options.js';
 import { resolvePaths } from './paths.js';
-import { ProbeError, ProbeServer } from './probe-server.js';
-import { CalciteError, defaultUsername, parseServer, } from './types.js';
+import { MOD_ERROR_LINE, gameStage } from './stage.js';
+import { CalciteError, defaultUsername, parseServer, parseWorld, } from './types.js';
 const NAME_RE = /^[A-Za-z0-9_.-]{1,64}$/;
 const MAX_LOG = 5000;
 const MAX_CHAT = 1000;
-/** Escapes a value for a java.util.Properties file. */
-function propValue(value) {
-    return value.replace(/\\/g, '\\\\').replace(/[:=]/g, (c) => `\\${c}`);
-}
-async function tcpReachable(host, port, timeoutMs = 3000) {
-    return new Promise((resolve) => {
-        const socket = new Socket();
-        const done = (ok) => {
-            socket.destroy();
-            resolve(ok);
-        };
-        socket.setTimeout(timeoutMs, () => done(false));
-        socket.once('error', () => done(false));
-        socket.connect(port, host, () => done(true));
-    });
-}
-/** Screens shown while joining or changing dimension; the player is not playable yet. */
-const LOADING_SCREEN = /LevelLoading|ReceivingLevel|ProgressScreen|ConnectScreen|GenericMessage|DownloadingTerrain/;
+const MAX_EVENTS = 1000;
 export const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 /** Process lifecycle of a client: preparing, launching, the probe connection, reconnects and shutdown. */
 export class ClientCore extends EventEmitter {
@@ -47,15 +29,15 @@ export class ClientCore extends EventEmitter {
     render;
     account;
     server;
+    world;
     phaseValue = 'idle';
-    logs = [];
-    chats = [];
+    logs = new Feed(MAX_LOG);
+    chats = new Feed(MAX_CHAT);
+    events = new Feed(MAX_EVENTS);
+    extensionJars = [];
     seq = 0;
-    probe = null;
-    run = null;
-    display = null;
+    current = null;
     releaseInstance = null;
-    probeConfig = null;
     game = null;
     mods = [];
     headlessValue = false;
@@ -66,7 +48,6 @@ export class ClientCore extends EventEmitter {
     startedAt;
     reconnects = 0;
     stopping = false;
-    poller = null;
     inGameSince = 0;
     relaunching = false;
     everInGame = false;
@@ -85,7 +66,10 @@ export class ClientCore extends EventEmitter {
         if (this.account.type === 'offline' && !/^[A-Za-z0-9_]{3,16}$/.test(this.account.username)) {
             throw new CalciteError('bad_username', `Offline username must be 3-16 letters, digits or underscores: "${this.account.username}"`);
         }
+        if (options.server && options.world)
+            throw new CalciteError('bad_option', 'Pass either a server or a world, not both');
         this.server = options.server ? parseServer(options.server) : undefined;
+        this.world = options.world ? parseWorld(options.world) : undefined;
         if (!parseLoader(options.loader) && options.mods?.length) {
             throw new CalciteError('bad_mod', 'Mods need a mod loader (loader "fabric", "forge" or "neoforge")');
         }
@@ -112,16 +96,12 @@ export class ClientCore extends EventEmitter {
     pushLog(source, line) {
         const entry = { seq: ++this.seq, time: Date.now(), source, line };
         this.logs.push(entry);
-        if (this.logs.length > MAX_LOG)
-            this.logs.splice(0, this.logs.length - MAX_LOG);
         this.emit('log', entry);
         if (source === 'game') {
             const chat = /\[CHAT\] (.*)$/.exec(line);
             if (chat) {
                 const c = { seq: entry.seq, time: entry.time, message: chat[1] };
                 this.chats.push(c);
-                if (this.chats.length > MAX_CHAT)
-                    this.chats.splice(0, this.chats.length - MAX_CHAT);
                 this.emit('chat', c);
             }
         }
@@ -129,7 +109,7 @@ export class ClientCore extends EventEmitter {
     // ------------------------------------------------------------------ lifecycle
     /**
      * Prepares everything (Java, game files, mappings), launches the client and resolves once it is in a world
-     * (or on the title screen when no server is configured).
+     * (or on the title screen when neither a server nor a world is configured).
      */
     async start() {
         if (!['idle', 'stopped', 'crashed'].includes(this.phaseValue)) {
@@ -180,6 +160,9 @@ export class ClientCore extends EventEmitter {
         await syncMods(this.gameDir, this.mods);
         for (const m of this.mods)
             this.note(`mod ${m.name} (${m.source})`);
+        this.extensionJars = await resolveExtensions(this.paths, this.options.extensions ?? []);
+        for (const jar of this.extensionJars)
+            this.note(`extension ${jar}`);
     }
     resolveHeadless() {
         if (this.render === 'off')
@@ -190,61 +173,47 @@ export class ClientCore extends EventEmitter {
         }
         return false;
     }
+    requireGame() {
+        if (!this.game)
+            throw new CalciteError('not_prepared', 'prepare() has not completed');
+        return this.game;
+    }
     async launch() {
-        const { json, java, loader, names, hmcJar } = this.game;
+        const game = this.requireGame();
+        const { json, java, loader, names } = game;
         const probeJar = await installProbe(this.paths);
-        if (this.server) {
-            this.setPhase('waiting_for_server');
-            const deadline = Date.now() + (this.options.waitForServerMs ?? 120_000);
-            while (!(await tcpReachable(this.server.host, this.server.port))) {
-                if (this.stopping)
-                    throw new CalciteError('stopped', 'Stopped while waiting for the server');
-                if (Date.now() > deadline)
-                    throw new CalciteError('server_unreachable', `Server ${this.server.host}:${this.server.port} is not reachable`);
-                await sleep(2000);
-            }
-        }
-        // probe endpoint + config (paths inside may contain spaces; the config file itself lives in a safe dir)
-        this.probe = new ProbeServer();
-        await this.probe.listen();
-        this.probe.on('connected', () => this.onProbeConnected());
-        this.probe.on('disconnected', () => this.note('probe disconnected'));
-        this.probeConfig = join(this.paths.probe, `${this.options.name}-${randomBytes(6).toString('hex')}.properties`);
-        const cfg = [
-            `port=${this.probe.port}`,
-            `token=${this.probe.token}`,
-            // name tables the probe tries in order (a mapping file or "official")
-            ...(names.kind === 'probe' ? names.candidates.map((c, i) => `mappings.${i + 1}=${propValue(c)}`) : []),
-            `headless=${this.headlessValue}`,
-            `render=${this.render === 'always' ? 'on' : 'off'}`,
-            'exitOnDisconnect=true',
-            '',
-        ].join('\n');
-        await mkdir(this.paths.probe, { recursive: true });
-        await writeFile(this.probeConfig, cfg, { mode: 0o600 });
+        if (this.server)
+            await this.waitForServer(this.server);
+        // offline accounts may only render on a virtual display (HeadlessMC); on-demand clients stay invisible when Xvfb exists
+        const forceVirtual = this.account.type === 'offline' || (this.render === 'on-demand' && which('Xvfb') !== null);
+        const run = await GameRun.open({
+            dir: this.paths.probe,
+            name: this.options.name,
+            probe: {
+                mappings: names.kind === 'probe' ? names.candidates : [],
+                version: json.id,
+                extensions: this.extensionJars,
+                headless: this.headlessValue,
+                render: this.render,
+            },
+            display: this.headlessValue ? undefined : { forceVirtual },
+        });
+        this.current = run;
+        run.probe.on('connected', () => this.onProbeConnected(run));
+        run.probe.on('disconnected', () => this.note('probe disconnected'));
+        run.probe.on('event', (e) => {
+            const event = { seq: ++this.seq, time: e.time, name: e.name, data: e.data };
+            this.events.push(event);
+            this.emit('event', event);
+        });
         await writeOptions(this.gameDir, defaultOptions({ renderDistance: this.options.renderDistance, maxFps: this.options.maxFps }));
-        let displayEnv = {};
-        let virtualDisplay = false;
-        if (!this.headlessValue) {
-            // offline accounts may only render on a virtual display (HeadlessMC); on-demand clients stay invisible when Xvfb exists
-            this.display = await acquireDisplay({ forceVirtual: this.account.type === 'offline' || (this.render === 'on-demand' && which('Xvfb') !== null) });
-            displayEnv = this.display.env;
-            virtualDisplay = this.display.virtual;
-        }
-        const proxyArgs = Object.entries(javaProxyProps()).map(([k, v]) => `-D${k}=${v}`);
-        const jvmArgs = [`-Xmx${this.options.memory ?? '2G'}`, ...proxyArgs, ...(this.options.jvmArgs ?? [])];
-        if (names.kind !== 'unsupported')
-            jvmArgs.unshift(`-javaagent:${probeJar}=${this.probeConfig}`);
-        // HeadlessMC's stubbed LWJGL buffers have no native address; JOML's Unsafe path writes to it and crashes the JVM
-        if (this.headlessValue)
-            jvmArgs.unshift('-Djoml.nounsafe=true');
-        const gameArgs = [...(this.options.gameArgs ?? [])];
-        if (this.server) {
-            if (supportsQuickPlay(json))
-                gameArgs.unshift('--quickPlayMultiplayer', `${this.server.host}:${this.server.port}`);
-            else
-                gameArgs.unshift('--server', this.server.host, '--port', String(this.server.port));
-        }
+        const jvmArgs = gameJvmArgs({
+            agent: names.kind === 'unsupported' ? undefined : `${probeJar}=${run.configFile}`,
+            headless: this.headlessValue,
+            memory: this.options.memory,
+            extra: this.options.jvmArgs,
+        });
+        const gameArgs = [...(this.server ? joinArgs(this.server, supportsQuickPlay(json)) : []), ...(this.options.gameArgs ?? [])];
         const offline = this.account.type === 'offline';
         // a private HeadlessMC location per client: its own account selection, config and caches
         const location = join(this.gameDir, '.headlessmc');
@@ -257,164 +226,171 @@ export class ClientCore extends EventEmitter {
             throw code ? new CalciteError(code, err.message) : err;
         }
         await writeHmcProfile(location, json.id, this.gameDir, java.major, loader);
-        const props = {
-            'hmc.files.mc': this.paths.minecraft,
-            'hmc.files.game': this.gameDir,
-            'hmc.java.versions': hmcListEntry(java.path),
-            'hmc.java.download': 'false',
-            // HeadlessMC only lets offline accounts render when it sees Xvfb running
-            'hmc.xvfb.check': String(virtualDisplay),
-        };
-        const command = [
-            'launch',
-            ...hmcVersionArgs(json.id, loader),
-            ...(offline ? ['--offline'] : []),
-            ...(this.headlessValue ? ['--headless'] : []),
-            `--jvm=${jvmArgs.map(hmcQuote).join(' ')}`,
-            ...(gameArgs.length ? [`--game=${gameArgs.map(hmcQuote).join(' ')}`] : []),
-        ];
-        const env = { ...process.env, ...displayEnv };
-        const sync = () => {
-            if (!offline)
-                void syncAccount(this.paths, location, accountName).catch((err) => this.note(`account sync failed: ${err.message}`));
+        const props = hmcProperties({
+            minecraftDir: this.paths.minecraft,
+            gameDir: this.gameDir,
+            javaPath: java.path,
+            virtualDisplay: run.display?.virtual ?? false,
+            assetsVerified: await assetsVerified(this.paths, json),
+        });
+        // the session HeadlessMC refreshed before launching goes back to the shared store
+        const syncSession = () => {
+            if (offline)
+                return;
+            syncAccount(this.paths, location, accountName).catch((err) => {
+                this.note(`account sync failed: ${err.message}`);
+            });
         };
         this.setPhase('starting');
         this.joinRequested = false;
         this.startedAt = Date.now();
-        const spawnGame = async () => {
-            let launched;
-            const launchedPromise = new Promise((r) => (launched = r));
-            // 26.x+: when no graphics backend can be created the game opens a modal error box and blocks forever
-            const backendErrors = [];
-            let backendTimer;
-            const noBackend = () => {
-                if (run !== this.run || this.stopping)
-                    return;
-                const hint = process.platform === 'linux'
-                    ? ' On Linux without a GPU install Mesa EGL (apt install libegl1 libegl-mesa0) or Vulkan (apt install mesa-vulkan-drivers), or use render "off".'
-                    : ' Update the graphics drivers, or use render "off".';
-                this.fatalCode = 'renderer_unavailable';
-                this.lastError = `No graphics backend could be created: ${backendErrors.join('; ')}.${hint}`;
-                this.note(this.lastError);
-                this.setPhase('crashed');
-                void killTree(run.child);
-            };
-            this.run = runHmc({
-                javaPath: this.game.launcherJava.path,
-                hmcJar,
-                location,
-                props,
-                command,
-                env,
-                onLine: (line) => {
-                    this.pushLog('game', line);
-                    if (/Setting user:|Minecraft exited|LWJGL Version|Backend library/i.test(line))
-                        launched();
-                    const failure = /BackendCreationException: (.*)/.exec(line);
-                    if (failure) {
-                        backendErrors.push(failure[1].trim());
-                        clearTimeout(backendTimer);
-                        backendTimer = setTimeout(noBackend, 20_000);
-                    }
-                    else if (/Using graphics backend/.test(line))
-                        clearTimeout(backendTimer);
-                },
-            });
-            const run = this.run;
-            void run.exited.then(() => clearTimeout(backendTimer));
-            void run.exited.then((code) => {
-                sync();
-                this.onGameExit(run, code);
-            });
-            // the session HeadlessMC refreshed before launching goes back to the shared store
-            void launchedPromise.then(sync);
-        };
-        await spawnGame();
+        this.spawn(run, {
+            javaPath: game.launcherJava.path,
+            hmcJar: game.hmcJar,
+            location,
+            props,
+            command: hmcLaunchCommand({ versionId: json.id, loader, offline, headless: this.headlessValue, jvmArgs, gameArgs }),
+            env: { ...process.env, ...run.display?.env },
+            onLaunched: syncSession,
+            onExit: syncSession,
+        });
+    }
+    async waitForServer(server) {
+        this.setPhase('waiting_for_server');
+        await waitForServer(server, {
+            timeoutMs: this.options.waitForServerMs ?? 120_000,
+            stopped: () => this.stopping,
+            onWaiting: (message) => {
+                this.note(message);
+                this.log.info(message);
+            },
+        });
+    }
+    /** Starts HeadlessMC and follows the game's output until it exits. */
+    spawn(run, opts) {
+        let launched = false;
+        const backend = new BackendWatch((errors) => {
+            if (run !== this.current || this.stopping)
+                return;
+            this.fail('renderer_unavailable', `No graphics backend could be created: ${errors.join('; ')}. ${noBackendHint(process.platform)}`);
+        });
+        const hmc = runHmc({
+            ...opts,
+            onLine: (line) => {
+                this.pushLog('game', line);
+                backend.line(line);
+                if (!launched && /Setting user:|Minecraft exited|LWJGL Version|Backend library/i.test(line)) {
+                    launched = true;
+                    opts.onLaunched();
+                }
+            },
+        });
+        run.hmc = hmc;
+        void hmc.exited.then((code) => {
+            backend.dispose();
+            opts.onExit();
+            this.onGameExit(run, code);
+        });
     }
-    async onProbeConnected() {
+    onProbeConnected(run) {
         this.note('probe connected');
+        // the game JVM only starts once HeadlessMC has downloaded and verified every asset
+        if (this.game)
+            void markAssetsVerified(this.paths, this.game.json).catch(() => undefined);
         if (this.phaseValue === 'starting' || this.phaseValue === 'reconnecting')
             this.setPhase('connecting');
-        if (!this.poller) {
-            this.poller = setInterval(() => void this.poll(), 1000);
-        }
+        run.poll(() => void this.poll(run), 1000);
     }
-    async poll() {
-        if (!this.probe?.connected)
+    async poll(run) {
+        if (run !== this.current || !run.probe.connected)
             return;
         let state;
         try {
-            state = await this.probe.request('state', {}, 10_000);
+            state = await run.probe.request('state', {}, 10_000);
         }
-        catch (err) {
-            if (err instanceof ProbeError && err.code === 'not_ready')
-                return;
-            return;
+        catch {
+            return; // not ready yet, or the connection is going away: the next poll tells
         }
         const prev = this.lastState;
         this.lastState = state;
         if (JSON.stringify(prev) !== JSON.stringify(state))
             this.emit('state', state);
-        if (state.screen && /LoadingErrorScreen|ModLoadingError/.test(state.screen) && !this.fatalCode && this.run) {
-            // Forge/NeoForge stay on an error screen when mods fail to load; relaunching would not help
-            const errors = this.logs.filter((l) => l.source === 'game' && /\/(ERROR|FATAL)\]|Exception|[Mm]issing|requires/.test(l.line)).slice(-12);
-            this.fatalCode = 'mod_loading_failed';
-            this.lastError = `Mod loading failed (${state.screen}); check the mods and the loader version:\n${errors.map((l) => l.line).join('\n')}`;
-            this.note(this.lastError);
-            this.setPhase('crashed');
-            void killTree(this.run.child);
-            return;
-        }
-        if (state.inGame && !state.loading && !LOADING_SCREEN.test(state.screen ?? '')) {
-            if (this.phaseValue !== 'in_game') {
-                this.inGameSince = Date.now();
-                this.everInGame = true;
-                this.setPhase('in_game');
-            }
-            else if (this.reconnects > 0 && Date.now() - this.inGameSince > 60_000) {
-                this.reconnects = 0; // stable again
-            }
-        }
-        else if (this.server &&
-            !this.joinRequested &&
-            this.phaseValue === 'connecting' &&
-            state.screen === 'TitleScreen' &&
-            !state.loading) {
-            // Pre-1.20 versions may ignore --server (e.g. 1.16.4+ when multiplayer privileges cannot be checked)
-            this.joinRequested = true;
-            this.note(`joining ${this.server.host}:${this.server.port} from the title screen`);
-            this.probe.request('connect', { host: this.server.host, port: this.server.port }).catch((err) => this.note(`join failed: ${err.message}`));
-        }
-        else if (state.screen === 'DisconnectedScreen' && this.phaseValue !== 'disconnected' && this.phaseValue !== 'reconnecting') {
-            this.lastError = `Disconnected: ${state.disconnectReason ?? 'unknown reason'}`;
-            this.setPhase('disconnected');
-            void this.maybeReconnect();
+        switch (gameStage(state)) {
+            case 'mod_error':
+                if (!this.fatalCode)
+                    this.failModLoading(state.screen ?? '?');
+                break;
+            case 'playing':
+                if (this.phaseValue !== 'in_game') {
+                    this.inGameSince = Date.now();
+                    this.everInGame = true;
+                    this.setPhase('in_game');
+                }
+                else if (this.reconnects > 0 && Date.now() - this.inGameSince > 60_000) {
+                    this.reconnects = 0; // stable again
+                }
+                break;
+            case 'title':
+                if (this.joinRequested || this.phaseValue !== 'connecting')
+                    break;
+                // Pre-1.20 versions may ignore --server (e.g. 1.16.4+ when multiplayer privileges cannot be checked)
+                if (this.server)
+                    this.joinFromTitle(run.probe, 'connect', { host: this.server.host, port: this.server.port });
+                else if (this.world)
+                    this.joinFromTitle(run.probe, 'open_world', { ...this.world });
+                break;
+            case 'disconnected':
+                if (this.phaseValue !== 'disconnected' && this.phaseValue !== 'reconnecting') {
+                    this.lastError = `Disconnected: ${state.disconnectReason ?? 'unknown reason'}`;
+                    this.setPhase('disconnected');
+                    void this.maybeReconnect();
+                }
+                break;
+            case 'loading':
+                break;
         }
     }
-    reconnectLimit() {
-        const r = this.options.reconnect;
-        if (r === false)
-            return 0;
-        if (typeof r === 'object')
-            return r.maxAttempts ?? 10;
-        return 10;
+    /** Forge/NeoForge stay on an error screen when mods fail to load; relaunching would not help. */
+    failModLoading(screen) {
+        const errors = this.logs.since(0, (l) => l.source === 'game' && MOD_ERROR_LINE.test(l.line), 12);
+        this.fail('mod_loading_failed', `Mod loading failed (${screen}); check the mods and the loader version:\n${errors.map((l) => l.line).join('\n')}`);
+    }
+    /** A failure relaunching cannot fix: start() reports {@code code} and the game is killed. */
+    fail(code, message) {
+        this.fatalCode = code;
+        this.lastError = message;
+        this.note(message);
+        this.setPhase('crashed');
+        if (this.current?.hmc)
+            void killTree(this.current.hmc.child);
+    }
+    joinFromTitle(probe, op, args) {
+        this.joinRequested = true;
+        this.note(`${op} ${JSON.stringify(args)} from the title screen`);
+        probe.request(op, args, 90_000).catch((err) => {
+            const e = err;
+            this.note(`join failed: ${e.message}`);
+            if (e.code === 'unknown_world')
+                this.fail(e.code, e.message);
+        });
     }
     async maybeReconnect() {
-        if (this.stopping || this.relaunching || !this.server)
+        if (this.stopping || this.relaunching || !(this.server ?? this.world))
             return;
-        if (this.reconnects >= this.reconnectLimit()) {
+        if (this.reconnects >= reconnectLimit(this.options.reconnect)) {
             this.note(`not reconnecting: ${this.reconnects} attempts used`);
             return;
         }
         this.relaunching = true;
         try {
             this.reconnects++;
-            const delay = Math.min(5000 * 2 ** (this.reconnects - 1), 60_000);
+            const delay = reconnectDelay(this.reconnects);
             this.setPhase('reconnecting');
             this.note(`reconnecting in ${delay}ms (attempt ${this.reconnects})`);
-            if (this.run)
-                await killTree(this.run.child);
+            if (this.current?.hmc)
+                await killTree(this.current.hmc.child);
             await sleep(delay);
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- stop() may run while sleeping
             if (this.stopping)
                 return;
             await this.cleanupRun();
@@ -429,13 +405,16 @@ export class ClientCore extends EventEmitter {
         }
     }
     onGameExit(run, code) {
-        if (run !== this.run)
+        if (run !== this.current)
             return; // an older run
         this.emit('exit', code);
         this.note(`game process exited with code ${code}`);
         if (this.stopping || this.relaunching || this.fatalCode)
             return;
-        const tail = this.logs.filter((l) => l.source === 'game').slice(-15).map((l) => l.line).join('\n');
+        const tail = this.logs
+            .since(0, (l) => l.source === 'game', 15)
+            .map((l) => l.line)
+            .join('\n');
         this.lastError = `Game exited with code ${code}${tail ? `:\n${tail}` : ''}`;
         this.setPhase('crashed');
         // a crash during the very first start is reported to start(); later crashes are retried
@@ -448,11 +427,11 @@ export class ClientCore extends EventEmitter {
             const phase = this.phaseValue;
             if (phase === 'in_game')
                 return;
-            if (!this.server && this.lastState?.ready && this.lastState.loading === false && phase === 'connecting')
+            if (!this.server && !this.world && this.lastState?.ready && this.lastState.loading === false && phase === 'connecting')
                 return;
             if (phase === 'crashed')
                 throw new CalciteError(this.fatalCode ?? 'crashed', this.lastError ?? 'The game crashed during startup');
-            if (phase === 'disconnected' && this.reconnectLimit() === 0)
+            if (phase === 'disconnected' && reconnectLimit(this.options.reconnect) === 0)
                 throw new CalciteError('disconnected', this.lastError ?? 'Disconnected');
             if (Date.now() > deadline)
                 throw new CalciteError('start_timeout', `Client did not start within ${timeoutMs}ms (phase ${phase})`);
@@ -460,25 +439,10 @@ export class ClientCore extends EventEmitter {
         }
     }
     async cleanupRun() {
-        if (this.poller) {
-            clearInterval(this.poller);
-            this.poller = null;
-        }
-        if (this.run) {
-            await killTree(this.run.child);
-            this.run = null;
-        }
-        if (this.probe) {
-            await this.probe.close();
-            this.probe = null;
-        }
-        if (this.probeConfig) {
-            await rm(this.probeConfig, { force: true });
-            this.probeConfig = null;
-        }
-        this.display?.release();
-        this.display = null;
+        const run = this.current;
+        this.current = null;
         this.lastState = undefined;
+        await run?.dispose();
     }
     async shutdown(final) {
         this.stopping = true;
@@ -493,38 +457,57 @@ export class ClientCore extends EventEmitter {
     async stop() {
         if (this.phaseValue === 'stopped' || this.phaseValue === 'idle')
             return;
+        const saveWorld = this.world && this.phaseValue === 'in_game' && this.probeConnected;
         this.setPhase('stopping');
+        if (saveWorld)
+            await this.closeWorld();
         await this.shutdown('stopped');
     }
+    /** Lets the integrated server save and stop before the game is killed. */
+    async closeWorld() {
+        try {
+            await this.requireProbe().request('close_world', {}, 60_000);
+            this.note('world saved');
+        }
+        catch (err) {
+            this.note(`saving the world failed: ${err.message}`);
+        }
+    }
     status() {
         return {
             name: this.options.name,
             version: this.game?.json.id ?? this.options.version,
             loader: this.game?.loader ? `${this.game.loader.kind}@${this.game.loader.build}` : this.options.loader,
             mods: this.mods.length ? this.mods.map((m) => m.name) : undefined,
+            extensions: this.extensionJars.length ? this.extensionJars : undefined,
             phase: this.phaseValue,
             render: this.render,
             headless: this.headlessValue,
             account: this.account,
             server: this.server,
+            world: this.world,
             gameDir: this.gameDir,
-            pid: this.run?.child.pid,
+            pid: this.current?.hmc?.child.pid,
             java: this.game?.java.version,
             startedAt: this.startedAt,
             reconnects: this.reconnects,
             lastError: this.lastError,
-            probeConnected: !!this.probe?.connected,
+            probeConnected: this.probeConnected,
             game: this.lastState,
         };
     }
     // ------------------------------------------------------------------ operations
+    get probeConnected() {
+        return !!this.current?.probe.connected;
+    }
     requireProbe() {
         if (this.game?.names.kind === 'unsupported') {
             throw new CalciteError('unsupported_version', this.game.names.reason);
         }
-        if (!this.probe?.connected)
+        const probe = this.current?.probe;
+        if (!probe?.connected)
             throw new CalciteError('not_connected', `Client "${this.options.name}" is not running (phase ${this.phaseValue})`);
-        return this.probe;
+        return probe;
     }
 }
 //# sourceMappingURL=client-core.js.map