stonecut-map-builder 0.0.0-stage → 0.1.0

package/dist/ops/world.js

@@ -0,0 +1,370 @@
+import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { cloneCommand, fillCommands, isAir, packPlacements, schematicPlacements, } from '../mc/blocks.js';
+import { boxAt, boxSize, boxVolume, chunkCount, chunksOf, makeBox, splitBox, unionBox } from '../mc/box.js';
+import { STATE_DIR } from '../mc/testserver.js';
+import { emptyResult, mergeResults, runInOrder, runParallel } from '../rcon/rcon.js';
+import { resolveInside, shown } from '../safety/paths.js';
+import { readSponge, schematicByteLimit, writeSponge } from '../schematic/sponge.js';
+import { AIR, readArea, regionDir } from '../world/region.js';
+import { readEntities, toSchematicEntities } from '../world/entities.js';
+import { removeCommands, summonCommands, uuidString } from '../mc/entities.js';
+import { UndoStore } from './undo.js';
+// Block work on the test server: keeps the area loaded, takes a snapshot for undo first,
+// then sends the commands in batches over RCON.
+const PARALLEL = 4;
+const MAX_CHUNKS = 1024;
+export class WorldError extends Error {
+}
+const DIM_ID = { overworld: 'minecraft:overworld', the_nether: 'minecraft:the_nether', the_end: 'minecraft:the_end' };
+export function inDimension(dim, cmd) {
+    return dim === 'overworld' ? cmd : `execute in ${DIM_ID[dim]} run ${cmd}`;
+}
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function checkChunks(n) {
+    if (n > MAX_CHUNKS)
+        throw new WorldError(`That touches ${n} chunks; the limit is ${MAX_CHUNKS} per call. Split the work into smaller areas.`);
+}
+export class World {
+    server;
+    config;
+    undo;
+    constructor(server, config) {
+        this.server = server;
+        this.config = config;
+        this.undo = new UndoStore(join(server.dir, STATE_DIR, 'undo'), config.undoHistory);
+    }
+    async cmd(c) {
+        return (await this.server.connection()).command(c);
+    }
+    /** Asks the server to write everything to disk, so the region files match the world. */
+    async save() {
+        const reply = await this.cmd('save-all flush');
+        if (/error|failed/i.test(reply))
+            throw new WorldError(`Saving failed: ${reply}`);
+    }
+    async read(box, dim, withEntities = false) {
+        await this.save();
+        const area = await readArea(regionDir(this.server.worldDir, dim), box);
+        if (!withEntities)
+            return { ...area, entities: [] };
+        const entities = await readEntities(regionDir(this.server.worldDir, dim, 'entities'), box);
+        this.checkEntities(entities.length, 'The area has');
+        area.schematic.entities = toSchematicEntities(entities, box);
+        area.schematic.origin = [...box.min];
+        return { ...area, entities };
+    }
+    /** Entities in the area right now (saved first). */
+    async entitiesIn(box, dim) {
+        checkChunks(chunkCount(box));
+        await this.save();
+        return readEntities(regionDir(this.server.worldDir, dim, 'entities'), box);
+    }
+    checkEntities(n, what) {
+        if (n > this.config.maxEntities) {
+            throw new WorldError(`${what} ${n} entities, over the limit of ${this.config.maxEntities} (maxEntities in the config). Use a smaller area, or include_entities: false.`);
+        }
+    }
+    /** Removes entities without loot (living ones get an empty loot table first). */
+    async removeEntities(list, dim) {
+        if (!list.length)
+            return { removed: 0, result: emptyResult() };
+        const result = await runInOrder(await this.server.connection(), removeCommands(list).map((c) => inDimension(dim, c)), 1000);
+        result.errors = result.errors.filter((e) => !e.command.includes('DeathLootTable'));
+        return { removed: list.length, result };
+    }
+    /** UUIDs of the items and XP orbs in and right around the box, before a change. */
+    async dropsBefore(box, dim) {
+        return new Set((await this.entitiesIn(grow(box), dim)).filter(isDrop).map((e) => e.uuid?.join(',') ?? ''));
+    }
+    /**
+     * Removes items and XP orbs that appeared in or right around the box during a change: blocks such as
+     * doors and torches pop off when what holds them is cleared, and leads drop when their mob goes.
+     */
+    async sweepDrops(box, dim, before) {
+        await sleep(100);
+        const drops = (await this.entitiesIn(grow(box), dim)).filter((e) => isDrop(e) && e.uuid && !before.has(e.uuid.join(',')));
+        await runInOrder(await this.server.connection(), drops.map((e) => inDimension(dim, `kill ${uuidString(e.uuid)}`)));
+        return drops.length;
+    }
+    /** Summons schematic entities with their corner at origin, in order (a summon may be followed by data merges). */
+    async summonEntities(entities, origin, oldOrigin, dim, warnings) {
+        if (!entities.length)
+            return { summoned: 0, result: emptyResult() };
+        const plan = summonCommands(entities, origin, oldOrigin);
+        warnings.push(...plan.warnings);
+        const result = await runInOrder(await this.server.connection(), plan.commands.map((c) => inDimension(dim, c)), 1000);
+        const summoned = plan.commands.filter((c) => c.startsWith('summon ')).length - result.errors.filter((e) => e.command.includes('summon ')).length;
+        return { summoned, result };
+    }
+    /** Whether an entity with this UUID is alive anywhere loaded. A mob in its death animation counts as gone. */
+    async alive(uuid) {
+        const r = await this.cmd(`data get entity ${uuid} Health`);
+        if (/No entity was found/i.test(r))
+            return false;
+        const m = /:\s*(-?[\d.]+)f\s*$/.exec(r.trim());
+        return !(m && Number(m[1]) <= 0);
+    }
+    /** Force-loads the chunks of boxes while fn runs, then releases only the ones it added. */
+    async withLoaded(boxes, dim, fn) {
+        const keys = new Map();
+        for (const b of boxes) {
+            // Counted before listing, so a huge box is refused without listing its chunks.
+            checkChunks(chunkCount(b));
+            for (const c of chunksOf(b))
+                keys.set(`${c[0]},${c[1]}`, c);
+        }
+        checkChunks(keys.size);
+        const listed = await this.cmd(inDimension(dim, 'forceload query'));
+        const already = new Set([...listed.matchAll(/\[(-?\d+), (-?\d+)\]/g)].map((m) => `${m[1]},${m[2]}`));
+        const added = [...keys.entries()].filter(([k]) => !already.has(k)).map(([, c]) => c);
+        const conns = await this.server.connections(PARALLEL);
+        const add = await runParallel(conns, added.map(([cx, cz]) => inDimension(dim, `forceload add ${cx * 16} ${cz * 16}`)));
+        try {
+            if (add.errors.length)
+                throw new WorldError(`Could not load the area: ${add.errors[0].reply}`);
+            await this.waitLoaded([...keys.values()], dim);
+            return await fn();
+        }
+        finally {
+            await runParallel(conns, added.map(([cx, cz]) => inDimension(dim, `forceload remove ${cx * 16} ${cz * 16}`))).catch(() => undefined);
+        }
+    }
+    async waitLoaded(chunks, dim, timeoutMs = 60_000) {
+        let pending = chunks;
+        const until = Date.now() + timeoutMs;
+        const conns = await this.server.connections(PARALLEL);
+        while (pending.length) {
+            const still = [];
+            let next = 0;
+            await Promise.all(conns.map(async (c) => {
+                while (next < pending.length) {
+                    const ch = pending[next++];
+                    const r = await c.command(inDimension(dim, `execute if loaded ${ch[0] * 16} 0 ${ch[1] * 16}`));
+                    if (!/passed/i.test(r))
+                        still.push(ch);
+                }
+            }));
+            pending = still;
+            if (!pending.length)
+                return;
+            if (Date.now() > until)
+                throw new WorldError(`${pending.length} chunks did not load within ${timeoutMs / 1000}s`);
+            await sleep(200);
+        }
+    }
+    /** Saves the area as it is now, so undo can put it back. Null when automatic backups are off. */
+    async snapshot(box, dim, label, opts) {
+        if (!this.config.autoBackup)
+            return null;
+        const volume = boxVolume(box);
+        if (volume > this.config.maxImportBlocks) {
+            if (opts.skipBackup)
+                return null;
+            throw new WorldError(`The area is ${volume} blocks, too big for an undo snapshot (limit ${this.config.maxImportBlocks}). Run backup_world first, then call again with skip_backup: true.`);
+        }
+        const { schematic } = await this.read(box, dim, this.config.includeEntities);
+        return this.undo.push({ label, box, dimension: dim, blocks: volume, entities: this.config.includeEntities }, writeSponge(schematic, 3));
+    }
+    async runBatch(batch, dim) {
+        const conns = await this.server.connections(PARALLEL);
+        const first = await runParallel(conns, batch.first.map((c) => inDimension(dim, c)));
+        const second = await runInOrder(conns[0], batch.second.map((c) => inDimension(dim, c)));
+        return mergeResults(first, second);
+    }
+    result(r, warnings, undo, began, entities) {
+        return {
+            ...(entities ? { entities } : {}),
+            commands: r.ran,
+            changed: r.changed,
+            unchanged: r.unchanged,
+            errors: r.errors,
+            warnings,
+            undo: undo?.id ?? null,
+            seconds: Math.round((Date.now() - began) / 100) / 10,
+        };
+    }
+    checkSize(volume, what) {
+        if (volume > this.config.maxFillBlocks) {
+            throw new WorldError(`${what} covers ${volume} blocks, over the limit of ${this.config.maxFillBlocks} (maxFillBlocks in the config). Split it into smaller steps.`);
+        }
+    }
+    async place(placements, opts) {
+        const began = Date.now();
+        const box = unionBox(placements.map((p) => ({ min: p.pos, max: p.pos })));
+        this.checkSize(placements.length, 'This placement');
+        const batch = packPlacements(placements);
+        return this.withLoaded([box], opts.dimension, async () => {
+            const undo = await this.snapshot(box, opts.dimension, `place ${placements.length} blocks`, opts);
+            const r = await this.runBatch(batch, opts.dimension);
+            return this.result(r, batch.warnings, undo, began);
+        });
+    }
+    async fill(fills, opts, label = 'fill') {
+        const began = Date.now();
+        const total = fills.reduce((a, f) => a + boxVolume(f.box), 0);
+        this.checkSize(total, 'This fill');
+        const box = unionBox(fills.map((f) => f.box));
+        return this.withLoaded(fills.map((f) => f.box), opts.dimension, async () => {
+            const undo = await this.snapshot(box, opts.dimension, label, opts);
+            const conns = await this.server.connections(PARALLEL);
+            let r = emptyResult();
+            for (const f of fills) {
+                const cmds = fillCommands(f.box, f.state, f.mode, f.filter).map((c) => inDimension(opts.dimension, c));
+                const hollow = f.mode === 'hollow' || f.mode === 'outline';
+                r = mergeResults(r, hollow ? await runInOrder(conns[0], cmds) : await runParallel(conns, cmds));
+            }
+            return this.result(r, [], undo, began);
+        });
+    }
+    async copy(src, dest, masked, opts) {
+        const began = Date.now();
+        const destBox = boxAt(dest, boxSize(src));
+        this.checkSize(boxVolume(src), 'This copy');
+        const overlap = [0, 1, 2].every((i) => src.min[i] <= destBox.max[i] && destBox.min[i] <= src.max[i]);
+        const parts = splitBox(src, 32768);
+        if (overlap && parts.length > 1)
+            throw new WorldError('Source and destination overlap and the area is over 32768 blocks. Copy it in two steps through a free spot.');
+        return this.withLoaded([src, destBox], opts.dimension, async () => {
+            const undo = await this.snapshot(destBox, opts.dimension, 'copy', opts);
+            const cmds = parts.map((p) => {
+                const d = [dest[0] + p.min[0] - src.min[0], dest[1] + p.min[1] - src.min[1], dest[2] + p.min[2] - src.min[2]];
+                return inDimension(opts.dimension, cloneCommand(p, d, masked, overlap));
+            });
+            const r = await runInOrder(await this.server.connection(), cmds);
+            return this.result(r, [], undo, began);
+        });
+    }
+    /** Sets the box to air. With entities, removes the entities in it first (undo brings them back). */
+    async clear(box, opts, withEntities) {
+        const began = Date.now();
+        this.checkSize(boxVolume(box), 'This clear');
+        return this.withLoaded([box], opts.dimension, async () => {
+            const undo = await this.snapshot(box, opts.dimension, 'clear', opts);
+            const drops = await this.dropsBefore(box, opts.dimension);
+            let removed = 0;
+            let r = emptyResult();
+            if (withEntities) {
+                const gone = await this.removeEntities(await this.entitiesIn(box, opts.dimension), opts.dimension);
+                removed = gone.removed;
+                r = gone.result;
+            }
+            const conns = await this.server.connections(PARALLEL);
+            r = mergeResults(r, await runParallel(conns, fillCommands(box, AIR).map((c) => inDimension(opts.dimension, c))));
+            await this.sweepDrops(box, opts.dimension, drops);
+            return this.result(r, [], undo, began, withEntities ? { removed, summoned: 0 } : undefined);
+        });
+    }
+    /**
+     * Pastes a schematic with its corner at origin. includeAir clears the area first.
+     * Entities: 'replace' removes the entities in the area (when includeAir) and summons those of the
+     * schematic; 'restore' (undo) removes only entities that were not there before and summons only
+     * the missing ones.
+     */
+    async paste(s, origin, includeAir, opts, label, snapshot = true, entityMode = 'none') {
+        const began = Date.now();
+        const box = boxAt(origin, [s.width, s.height, s.length]);
+        const volume = boxVolume(box);
+        if (volume > this.config.maxImportBlocks) {
+            throw new WorldError(`The schematic is ${volume} blocks, over the limit of ${this.config.maxImportBlocks} (maxImportBlocks in the config).`);
+        }
+        const { placements, warnings } = schematicPlacements(s, origin);
+        const batch = packPlacements(placements);
+        warnings.push(...batch.warnings);
+        const entities = entityMode === 'none' ? [] : (s.entities ?? []);
+        this.checkEntities(entities.length, 'The schematic has');
+        const dim = opts.dimension;
+        return this.withLoaded([box], dim, async () => {
+            const undo = snapshot ? await this.snapshot(box, dim, label, opts) : null;
+            const drops = includeAir ? await this.dropsBefore(box, dim) : null;
+            let r = emptyResult();
+            let removed = 0;
+            let toSummon = entities;
+            if (entityMode === 'replace' && includeAir) {
+                const gone = await this.removeEntities(await this.entitiesIn(box, dim), dim);
+                removed = gone.removed;
+                r = gone.result;
+            }
+            else if (entityMode === 'restore') {
+                const before = new Set(entities.map((e) => snapshotUuid(e)).filter((u) => u !== null));
+                const added = (await this.entitiesIn(box, dim)).filter((e) => !e.uuid || !before.has(uuidString(e.uuid)));
+                const gone = await this.removeEntities(added, dim);
+                removed = gone.removed;
+                r = gone.result;
+                const missing = [];
+                for (const e of entities) {
+                    const u = snapshotUuid(e);
+                    if (u === null || !(await this.alive(u)))
+                        missing.push(e);
+                }
+                toSummon = missing;
+            }
+            if (includeAir) {
+                const conns = await this.server.connections(PARALLEL);
+                r = mergeResults(r, await runParallel(conns, fillCommands(box, AIR).map((c) => inDimension(dim, c))));
+            }
+            r = mergeResults(r, await this.runBatch(batch, dim));
+            if (drops)
+                await this.sweepDrops(box, dim, drops);
+            let summoned = 0;
+            if (entityMode !== 'none') {
+                const made = await this.summonEntities(toSummon, origin, s.origin, dim, warnings);
+                summoned = made.summoned;
+                r = mergeResults(r, made.result);
+            }
+            return this.result(r, warnings, undo, began, entityMode === 'none' ? undefined : { removed, summoned });
+        });
+    }
+    async importFile(file, origin, includeAir, opts, withEntities) {
+        const limit = schematicByteLimit(this.config.maxImportBlocks);
+        if (statSync(file).size > limit)
+            throw new WorldError(`${shown(this.server.dir, file)} is over ${limit} bytes, too big for a schematic within maxImportBlocks (${this.config.maxImportBlocks}).`);
+        const { schematic, version } = readSponge(readFileSync(file), { maxBlocks: this.config.maxImportBlocks, ...(withEntities ? { maxEntities: this.config.maxEntities } : {}) });
+        const r = await this.paste(schematic, origin, includeAir, opts, `import ${shown(this.server.dir, file)}`, true, withEntities ? 'replace' : 'none');
+        return { ...r, size: [schematic.width, schematic.height, schematic.length], version, dataVersion: schematic.dataVersion };
+    }
+    async exportFile(box, file, version, dim, withEntities) {
+        const volume = boxVolume(box);
+        if (volume > this.config.maxImportBlocks)
+            throw new WorldError(`The area is ${volume} blocks, over the limit of ${this.config.maxImportBlocks} (maxImportBlocks in the config).`);
+        const { schematic, missingChunks } = await this.read(box, dim, withEntities);
+        const data = writeSponge(schematic, version);
+        mkdirSync(dirname(file), { recursive: true });
+        writeFileSync(file, data);
+        let nonAir = 0;
+        for (const i of schematic.blocks)
+            if (!isAir(schematic.palette[i]))
+                nonAir++;
+        return { file: shown(this.server.dir, file), size: boxSize(box), blocks: volume, nonAir, blockEntities: schematic.blockEntities.length, entities: schematic.entities?.length ?? 0, bytes: data.length, missingChunks };
+    }
+    async undoLast() {
+        const last = this.undo.latest();
+        if (!last)
+            return null;
+        const { schematic } = readSponge(last.schem);
+        const r = await this.paste(schematic, last.entry.box.min, true, { dimension: last.entry.dimension }, 'undo', false, last.entry.entities ? 'restore' : 'none');
+        if (r.errors.length === 0)
+            this.undo.remove(last.entry.id);
+        return { ...r, label: last.entry.label };
+    }
+}
+/** The box with one more block on every side. */
+function grow(b) {
+    return { min: [b.min[0] - 1, b.min[1] - 1, b.min[2] - 1], max: [b.max[0] + 1, b.max[1] + 1, b.max[2] + 1] };
+}
+function isDrop(e) {
+    return e.id === 'minecraft:item' || e.id === 'minecraft:experience_orb';
+}
+function snapshotUuid(e) {
+    const u = e.data.value.get('UUID');
+    return u?.type === 'intArray' && u.value.length === 4 ? uuidString(u.value) : null;
+}
+export function boxFrom(from, to) {
+    return makeBox(from, to);
+}
+export function serverPath(server, rel) {
+    return resolveInside(server.dir, rel, { hidden: [STATE_DIR] });
+}
+export function exists(p) {
+    return existsSync(p);
+}

package/dist/rcon/rcon.js

@@ -0,0 +1,216 @@
+import { connect } from 'node:net';
+import { assertLoopback, assertPort, RCON_HOST } from '../safety/address.js';
+import { MAX_COMMAND_BYTES } from '../mc/blocks.js';
+// Source RCON protocol as Minecraft implements it: little-endian packets of
+// [length][request id][type][body\0][\0]. Type 3 logs in, type 2 runs a command, type 0 is a reply.
+// Minecraft reads one packet per read and drops the connection if two arrive together, so this
+// client waits for each reply before sending the next command.
+const TYPE_AUTH = 3;
+const TYPE_COMMAND = 2;
+/** Minecraft splits long replies into packets of this many characters. */
+const FRAGMENT = 4096;
+export class RconError extends Error {
+}
+export function encodePacket(id, type, body) {
+    const text = Buffer.from(body, 'utf8');
+    const buf = Buffer.alloc(14 + text.length);
+    buf.writeInt32LE(10 + text.length, 0);
+    buf.writeInt32LE(id, 4);
+    buf.writeInt32LE(type, 8);
+    text.copy(buf, 12);
+    return buf;
+}
+/** Takes whole packets off the front of buf. Returns them and the bytes left over. */
+export function decodePackets(buf) {
+    const packets = [];
+    let p = 0;
+    while (buf.length - p >= 4) {
+        const len = buf.readInt32LE(p);
+        if (len < 10 || len > 1024 * 1024)
+            throw new RconError(`Bad RCON packet length ${len}`);
+        if (buf.length - p - 4 < len)
+            break;
+        packets.push({ id: buf.readInt32LE(p + 4), type: buf.readInt32LE(p + 8), body: buf.toString('utf8', p + 12, p + 4 + len - 2) });
+        p += 4 + len;
+    }
+    return { packets, rest: buf.subarray(p) };
+}
+export class Rcon {
+    socket;
+    timeoutMs;
+    buf = Buffer.alloc(0);
+    nextId = 1;
+    waiting = null;
+    queue = Promise.resolve();
+    closed = false;
+    constructor(socket, timeoutMs) {
+        this.socket = socket;
+        this.timeoutMs = timeoutMs;
+        socket.setNoDelay(true);
+        socket.on('data', (d) => this.onData(d));
+        socket.on('error', (e) => this.fail(new RconError(`RCON connection error: ${e.message}`)));
+        socket.on('close', () => {
+            this.closed = true;
+            this.fail(new RconError('RCON connection closed by the server'));
+        });
+    }
+    static async connect(port, password, timeoutMs = 60_000, host = RCON_HOST) {
+        assertLoopback(host, 'RCON address');
+        assertPort(port, 'RCON port');
+        const socket = await new Promise((res, rej) => {
+            const s = connect({ host, port });
+            const t = setTimeout(() => {
+                s.destroy();
+                rej(new RconError(`No answer from RCON on ${host}:${port}`));
+            }, 5000);
+            s.once('connect', () => {
+                clearTimeout(t);
+                res(s);
+            });
+            s.once('error', (e) => {
+                clearTimeout(t);
+                rej(new RconError(`Cannot reach RCON on ${host}:${port}: ${e.message}`));
+            });
+        });
+        const rcon = new Rcon(socket, timeoutMs);
+        try {
+            await rcon.send(TYPE_AUTH, password);
+        }
+        catch (e) {
+            rcon.close();
+            throw e;
+        }
+        return rcon;
+    }
+    get isOpen() {
+        return !this.closed;
+    }
+    /** Runs one command and returns the server's reply text. */
+    command(cmd) {
+        if (/[\r\n\0]/.test(cmd))
+            return Promise.reject(new RconError('A command must be one line'));
+        const c = cmd.replace(/^\//, '');
+        if (Buffer.byteLength(c) > MAX_COMMAND_BYTES) {
+            return Promise.reject(new RconError(`Command is ${Buffer.byteLength(c)} bytes; RCON takes at most ${MAX_COMMAND_BYTES}`));
+        }
+        return this.send(TYPE_COMMAND, c);
+    }
+    close() {
+        this.closed = true;
+        this.socket.destroy();
+    }
+    send(type, body) {
+        const run = () => new Promise((resolve, reject) => {
+            if (this.closed)
+                return reject(new RconError('RCON connection is closed'));
+            const id = this.nextId++;
+            const timer = setTimeout(() => this.fail(new RconError(`RCON gave no reply within ${this.timeoutMs / 1000}s`)), this.timeoutMs);
+            this.waiting = { id, parts: [], resolve, reject, timer };
+            this.socket.write(encodePacket(id, type, body));
+        });
+        const p = this.queue.then(run, run);
+        this.queue = p.catch(() => undefined);
+        return p;
+    }
+    onData(d) {
+        let decoded;
+        try {
+            decoded = decodePackets(Buffer.concat([this.buf, d]));
+        }
+        catch (e) {
+            this.fail(e);
+            this.close();
+            return;
+        }
+        this.buf = decoded.rest;
+        for (const pkt of decoded.packets) {
+            const w = this.waiting;
+            if (!w)
+                continue;
+            if (pkt.id === -1) {
+                this.fail(new RconError('RCON refused the password'));
+                continue;
+            }
+            if (pkt.id !== w.id)
+                continue;
+            w.parts.push(pkt.body);
+            if (w.settle)
+                clearTimeout(w.settle);
+            if (pkt.body.length >= FRAGMENT)
+                w.settle = setTimeout(() => this.finish(w), 150);
+            else
+                this.finish(w);
+        }
+    }
+    finish(w) {
+        if (this.waiting !== w)
+            return;
+        clearTimeout(w.timer);
+        if (w.settle)
+            clearTimeout(w.settle);
+        this.waiting = null;
+        w.resolve(w.parts.join(''));
+    }
+    fail(e) {
+        const w = this.waiting;
+        if (!w)
+            return;
+        clearTimeout(w.timer);
+        if (w.settle)
+            clearTimeout(w.settle);
+        this.waiting = null;
+        w.reject(e);
+    }
+}
+const UNCHANGED = /^(Could not set the block|No blocks were (filled|cloned)|Nothing changed)/i;
+const ERROR = /(Unknown or incomplete command|Unknown block|Unknown command|Incorrect argument|Expected |Invalid |<--\[HERE\]|not loaded|out of (this|the) world|Too many blocks|Cannot |Can't |Could not |Unknown |is not a valid|Unable to |No entity was found)/i;
+export function classifyReply(reply) {
+    const r = reply.trim();
+    if (UNCHANGED.test(r))
+        return 'unchanged';
+    if (ERROR.test(r))
+        return 'error';
+    return 'ok';
+}
+/** Blocks a /fill, /clone or /setblock reply says it changed. */
+export function changedCount(reply) {
+    const m = /(\d+) block/i.exec(reply);
+    if (m)
+        return Number(m[1]);
+    return /^Changed the block/i.test(reply.trim()) ? 1 : 0;
+}
+export function mergeResults(a, b) {
+    return { ran: a.ran + b.ran, changed: a.changed + b.changed, ok: a.ok + b.ok, unchanged: a.unchanged + b.unchanged, errors: [...a.errors, ...b.errors].slice(0, 20) };
+}
+export function emptyResult() {
+    return { ran: 0, changed: 0, ok: 0, unchanged: 0, errors: [] };
+}
+/**
+ * Runs commands over several connections at once. Only for commands whose order does not
+ * matter (they touch different blocks). Stops early after too many errors.
+ */
+export async function runParallel(conns, commands, maxErrors = 20) {
+    const result = { ran: 0, changed: 0, ok: 0, unchanged: 0, errors: [] };
+    let next = 0;
+    const worker = async (c) => {
+        while (next < commands.length && result.errors.length < maxErrors) {
+            const cmd = commands[next++];
+            const reply = await c.command(cmd);
+            result.ran++;
+            const kind = classifyReply(reply);
+            if (kind === 'ok') {
+                result.ok++;
+                result.changed += changedCount(reply);
+            }
+            else if (kind === 'unchanged')
+                result.unchanged++;
+            else
+                result.errors.push({ command: cmd, reply: reply.trim() });
+        }
+    };
+    await Promise.all(conns.map(worker));
+    return result;
+}
+export async function runInOrder(conn, commands, maxErrors = 20) {
+    return runParallel([conn], commands, maxErrors);
+}

package/dist/safety/address.js

@@ -0,0 +1,44 @@
+import { isIP } from 'node:net';
+// The tool only ever talks to this computer. RCON is always 127.0.0.1; these checks also guard
+// server.properties so the test server never listens on a network address.
+export const RCON_HOST = '127.0.0.1';
+export class AddressError extends Error {
+}
+/** True for literal loopback addresses: 127.0.0.0/8, ::1 and ::ffff:127.x.x.x. Host names are not accepted. */
+export function isLoopback(host) {
+    const h = host.trim().replace(/^\[|\]$/g, '').toLowerCase();
+    if (isIP(h) === 4)
+        return h.split('.')[0] === '127';
+    if (isIP(h) === 6) {
+        if (h === '::1' || h === '0:0:0:0:0:0:0:1')
+            return true;
+        const mapped = /^(?:0{0,4}:){0,5}:?ffff:(\d+\.\d+\.\d+\.\d+)$/.exec(h) ?? /^::ffff:(\d+\.\d+\.\d+\.\d+)$/.exec(h);
+        return mapped !== null && isIP(mapped[1]) === 4 && mapped[1].split('.')[0] === '127';
+    }
+    return false;
+}
+export function assertLoopback(host, what) {
+    if (!isLoopback(host))
+        throw new AddressError(`${what} must be a loopback address such as 127.0.0.1, not "${host}". Only a test server on this computer is supported.`);
+}
+export function assertPort(port, what) {
+    if (!Number.isInteger(port) || port < 1024 || port > 65535)
+        throw new AddressError(`${what} must be a whole number from 1024 to 65535, not ${port}`);
+}
+/** Hosts the setup may download from. Every download is also checked against a published hash. */
+export const DOWNLOAD_HOSTS = ['piston-meta.mojang.com', 'piston-data.mojang.com', 'launchermeta.mojang.com', 'launcher.mojang.com', 'maven.neoforged.net'];
+export function assertDownloadUrl(url) {
+    let u;
+    try {
+        u = new URL(url);
+    }
+    catch {
+        throw new AddressError(`Not a URL: ${url}`);
+    }
+    if (u.protocol !== 'https:')
+        throw new AddressError(`Downloads must use https: ${url}`);
+    if (!DOWNLOAD_HOSTS.includes(u.hostname) || u.port !== '' || u.username || u.password) {
+        throw new AddressError(`Downloads only come from official sources (${DOWNLOAD_HOSTS.join(', ')}), not ${u.host}`);
+    }
+    return u;
+}