stonecut-map-builder 0.0.0-stage → 0.1.1

package/dist/mc/entities.js

@@ -0,0 +1,241 @@
+import { randomBytes } from 'node:crypto';
+import { get, nbt, num } from '../nbt/nbt.js';
+import { SnbtError, toSnbt } from '../nbt/snbt.js';
+import { MAX_COMMAND_BYTES } from './blocks.js';
+// Turns saved entities back into /summon commands at a new place. Every copy gets a fresh UUID,
+// and every reference to an entity of the same import (leads tied to another mob, riders and the
+// like) is pointed at the new UUID, so copies never clash with the originals or with each other.
+// Positions inside the data (the block a frame or painting hangs on, the fence a lead is tied to,
+// homes and hives) move by the same offset as the entity.
+export const ENTITY_ID = /^[a-z0-9_.-]+:[a-z0-9_./-]+$/;
+export class EntityError extends Error {
+}
+/** Whole-number world positions stored as [I; x, y, z]. */
+const POS_ARRAYS = [
+    'block_pos', 'leash', 'home_pos', 'hive_pos', 'flower_pos', 'sleeping_pos', 'beam_target', 'anchor_pos',
+    'wander_target', 'patrol_target', 'bound_pos', 'travel_pos', 'jukebox_pos',
+];
+/** Older form: a compound with X, Y and Z. */
+const POS_COMPOUNDS = ['Leash', 'HivePos', 'FlowerPos', 'BeamTarget', 'PatrolTarget', 'WanderTarget'];
+/** Oldest form: three separate ints. */
+const POS_TRIPLES = [
+    ['TileX', 'TileY', 'TileZ'], ['SleepingX', 'SleepingY', 'SleepingZ'], ['BoundX', 'BoundY', 'BoundZ'],
+    ['HomePosX', 'HomePosY', 'HomePosZ'], ['TravelPosX', 'TravelPosY', 'TravelPosZ'], ['APX', 'APY', 'APZ'],
+];
+export function uuidString(u) {
+    const hex = Array.from(u, (n) => (n >>> 0).toString(16).padStart(8, '0')).join('');
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+/** A random version 4 UUID as four ints, the way the game stores it. */
+export function randomUuid() {
+    const b = randomBytes(16);
+    b[6] = (b[6] & 0x0f) | 0x40;
+    b[8] = (b[8] & 0x3f) | 0x80;
+    return [0, 4, 8, 12].map((i) => b.readInt32BE(i));
+}
+export function cloneTag(t) {
+    switch (t.type) {
+        case 'compound': return { type: 'compound', value: new Map([...t.value].map(([k, v]) => [k, cloneTag(v)])) };
+        case 'list': return { type: 'list', itemType: t.itemType, value: t.value.map(cloneTag) };
+        case 'byteArray': return { type: t.type, value: Int8Array.from(t.value) };
+        case 'intArray': return { type: t.type, value: Int32Array.from(t.value) };
+        case 'longArray': return { type: t.type, value: BigInt64Array.from(t.value) };
+        default: return { ...t };
+    }
+}
+/** Moves every known position in the entity (and its riders) by d. Changes c in place. */
+export function shiftPositions(c, d) {
+    const pos = c.value.get('Pos');
+    if (pos?.type === 'list')
+        pos.value.forEach((t, i) => t.type === 'double' && (t.value += d[i]));
+    for (const k of POS_ARRAYS) {
+        const t = c.value.get(k);
+        if (t?.type === 'intArray' && t.value.length === 3)
+            t.value.forEach((v, i) => (t.value[i] = v + d[i]));
+    }
+    for (const k of POS_COMPOUNDS) {
+        const t = get(c, k, 'compound');
+        if (!t)
+            continue;
+        ['X', 'Y', 'Z'].forEach((axis, i) => {
+            const v = t.value.get(axis);
+            if (v?.type === 'int')
+                v.value += d[i];
+        });
+    }
+    for (const keys of POS_TRIPLES) {
+        keys.forEach((k, i) => {
+            const v = c.value.get(k);
+            if (v?.type === 'int')
+                v.value += d[i];
+        });
+    }
+    const riders = get(c, 'Passengers', 'list');
+    for (const r of riders?.value ?? [])
+        if (r.type === 'compound')
+            shiftPositions(r, d);
+}
+const uuidKey = (u) => Array.from(u).join(',');
+/** Collects the UUIDs of entities and their riders. */
+export function collectUuids(c, into = []) {
+    const u = get(c, 'UUID', 'intArray');
+    if (u && u.value.length === 4)
+        into.push(Array.from(u.value));
+    for (const r of get(c, 'Passengers', 'list')?.value ?? [])
+        if (r.type === 'compound')
+            collectUuids(r, into);
+    return into;
+}
+/** Replaces, anywhere in the tag, each four-int UUID found in map by its new value. Changes t in place. */
+export function remapUuids(t, map) {
+    if (t.type === 'intArray' && t.value.length === 4) {
+        const next = map.get(uuidKey(t.value));
+        if (next)
+            next.forEach((v, i) => (t.value[i] = v));
+    }
+    else if (t.type === 'compound') {
+        for (const v of t.value.values())
+            remapUuids(v, map);
+    }
+    else if (t.type === 'list') {
+        for (const v of t.value)
+            remapUuids(v, map);
+    }
+}
+/** The block a frame, painting or lead knot hangs on, if the entity is one. */
+export function hangingBlock(c) {
+    const bp = get(c, 'block_pos', 'intArray');
+    if (bp && bp.value.length === 3)
+        return [bp.value[0], bp.value[1], bp.value[2]];
+    const [x, y, z] = ['TileX', 'TileY', 'TileZ'].map((k) => num(c, k));
+    return x !== undefined && y !== undefined && z !== undefined ? [x, y, z] : null;
+}
+function coord(n) {
+    const s = String(n);
+    return /e/i.test(s) ? n.toFixed(10) : s;
+}
+function dropDeep(c, key) {
+    c.value.delete(key);
+    for (const r of get(c, 'Passengers', 'list')?.value ?? [])
+        if (r.type === 'compound')
+            dropDeep(r, key);
+}
+/**
+ * Builds /summon commands for schematic entities pasted with their 0,0,0 corner at origin.
+ * oldOrigin is where that corner was when exported, if known; otherwise the world position inside
+ * each entity's data is used to work out the offset.
+ */
+export function summonCommands(entities, origin, oldOrigin, budget = MAX_COMMAND_BYTES) {
+    const plan = { commands: [], uuids: [], warnings: [] };
+    const fresh = new Map();
+    for (const e of entities)
+        for (const u of collectUuids(e.data))
+            fresh.set(uuidKey(u), randomUuid());
+    const hanging = [];
+    const others = [];
+    for (const e of entities) {
+        if (e.id === 'minecraft:player' || e.id === 'player') {
+            plan.warnings.push('Skipped a player entity: players cannot be copied');
+            continue;
+        }
+        const id = e.id.includes(':') ? e.id : `minecraft:${e.id}`;
+        if (!ENTITY_ID.test(id)) {
+            plan.warnings.push(`Skipped an entity with an invalid id: ${e.id.slice(0, 60)}`);
+            continue;
+        }
+        const at = [origin[0] + e.pos[0], origin[1] + e.pos[1], origin[2] + e.pos[2]];
+        const data = cloneTag(e.data);
+        let d;
+        const saved = data.value.get('Pos');
+        const savedPos = saved?.type === 'list' && saved.value.length === 3 ? saved.value.map((t) => (t.type === 'double' ? t.value : NaN)) : null;
+        if (oldOrigin)
+            d = [origin[0] - oldOrigin[0], origin[1] - oldOrigin[1], origin[2] - oldOrigin[2]];
+        else if (savedPos && savedPos.every(Number.isFinite))
+            d = [0, 1, 2].map((i) => Math.round(at[i] - savedPos[i]));
+        else {
+            const hb = hangingBlock(data);
+            d = hb ? [0, 1, 2].map((i) => Math.floor(at[i]) - hb[i]) : [0, 0, 0];
+        }
+        shiftPositions(data, d);
+        if (!get(data, 'UUID', 'intArray')) {
+            const u = randomUuid();
+            data.value.set('UUID', nbt.intArray(u));
+            fresh.set(uuidKey(u), u);
+        }
+        remapUuids(data, fresh);
+        const newUuid = uuidString(get(data, 'UUID', 'intArray').value);
+        for (const u of collectUuids(data))
+            plan.uuids.push(uuidString(u));
+        data.value.delete('Pos');
+        data.value.delete('id');
+        dropDeep(data, 'Brain');
+        const hb = hangingBlock(data);
+        const place = hb ?? at;
+        const head = `summon ${id} ${place.map(coord).join(' ')} `;
+        const cmds = fitCommands(head, newUuid, data, budget, plan.warnings);
+        if (!cmds) {
+            plan.warnings.push(`Skipped ${id} at ${at.map((v) => v.toFixed(1)).join(' ')}: its data cannot go into a command`);
+            continue;
+        }
+        (hb ? hanging : others).push(cmds);
+    }
+    plan.commands = [...hanging.flat(), ...others.flat()];
+    return plan;
+}
+/** One summon if it fits; otherwise a summon with what fits and a data merge per remaining key. */
+function fitCommands(head, uuid, data, budget, warnings) {
+    let full;
+    try {
+        full = head + toSnbt(data);
+    }
+    catch (e) {
+        if (!(e instanceof SnbtError))
+            throw e;
+        full = '';
+    }
+    if (full && Buffer.byteLength(full) <= budget)
+        return [full];
+    const core = nbt.compound({ UUID: data.value.get('UUID') });
+    const merges = [];
+    for (const [k, v] of data.value) {
+        if (k === 'UUID')
+            continue;
+        let part;
+        try {
+            part = toSnbt(nbt.compound({ [k]: v }));
+        }
+        catch {
+            warnings.push(`Left out ${k} of an entity: it has text that cannot go into a command`);
+            continue;
+        }
+        const trial = nbt.compound(new Map([...core.value, [k, v]]));
+        if (Buffer.byteLength(head + toSnbt(trial)) <= budget)
+            core.value.set(k, v);
+        else if (k !== 'Passengers' && Buffer.byteLength(`data merge entity ${uuid} ${part}`) <= budget)
+            merges.push(`data merge entity ${uuid} ${part}`);
+        else
+            warnings.push(`Left out ${k} of an entity: it is too long for RCON`);
+    }
+    const summon = head + toSnbt(core);
+    return Buffer.byteLength(summon) <= budget ? [summon, ...merges] : null;
+}
+/** Commands that remove entities without loot: living ones get an empty loot table first. */
+export function removeCommands(list) {
+    const out = [];
+    const remove = (data) => {
+        // Riders first: killing a vehicle would only throw them off.
+        for (const r of get(data, 'Passengers', 'list')?.value ?? [])
+            if (r.type === 'compound')
+                remove(r);
+        const uuid = get(data, 'UUID', 'intArray');
+        if (!uuid || uuid.value.length !== 4)
+            return;
+        const u = uuidString(uuid.value);
+        if (data.value.has('Health'))
+            out.push(`data merge entity ${u} {DeathLootTable:"minecraft:empty"}`);
+        out.push(`kill ${u}`);
+    };
+    for (const e of list)
+        remove(e.data);
+    return out;
+}

package/dist/mc/java.js

@@ -0,0 +1,97 @@
+import { execFile } from 'node:child_process';
+import { existsSync, readdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { delimiter, join } from 'node:path';
+export const JAVA_SOURCES = [
+    { name: 'Eclipse Temurin (Adoptium)', url: 'https://adoptium.net/temurin/releases/' },
+    { name: 'Microsoft Build of OpenJDK', url: 'https://learn.microsoft.com/java/openjdk/download' },
+];
+export function javaInstallHint(major, platform = process.platform) {
+    const hints = JAVA_SOURCES.map((s) => `${s.name}, Java ${major}: ${s.url}`);
+    if (platform === 'win32')
+        hints.push(`Windows terminal: winget install EclipseAdoptium.Temurin.${major}.JRE`);
+    else if (platform === 'darwin')
+        hints.push(`macOS with Homebrew: brew install --cask temurin@${major}`);
+    else
+        hints.push(`Linux: your package manager, for example sudo apt install openjdk-${major}-jre-headless`);
+    return hints;
+}
+export function parseJavaVersion(output) {
+    const m = /version "([^"]+)"/.exec(output);
+    if (!m)
+        return null;
+    const v = m[1];
+    const parts = v.split(/[._+-]/).map((n) => parseInt(n, 10));
+    const major = parts[0] === 1 ? parts[1] : parts[0];
+    return Number.isFinite(major) ? { major, version: v } : null;
+}
+function exe() {
+    return process.platform === 'win32' ? 'java.exe' : 'java';
+}
+function subdirs(dir) {
+    try {
+        return readdirSync(dir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => join(dir, d.name));
+    }
+    catch {
+        return [];
+    }
+}
+/** Places Java is commonly installed, built from environment variables and the home folder only. */
+export function candidatePaths(env = process.env, home = homedir()) {
+    const out = [];
+    const bin = (dir) => join(dir, 'bin', exe());
+    if (env.JAVA_HOME)
+        out.push(bin(env.JAVA_HOME));
+    for (const p of (env.PATH ?? env.Path ?? '').split(delimiter))
+        if (p)
+            out.push(join(p, exe()));
+    const vendorRoots = [];
+    if (process.platform === 'win32') {
+        for (const pf of [env.ProgramFiles, env['ProgramFiles(x86)']]) {
+            if (!pf)
+                continue;
+            for (const v of ['Java', 'Eclipse Adoptium', 'Microsoft', 'Zulu', 'Amazon Corretto', 'BellSoft', 'Semeru', 'OpenJDK'])
+                vendorRoots.push(join(pf, v));
+        }
+    }
+    else if (process.platform === 'darwin') {
+        for (const root of ['/Library/Java/JavaVirtualMachines', join(home, 'Library', 'Java', 'JavaVirtualMachines')]) {
+            for (const d of subdirs(root))
+                out.push(bin(join(d, 'Contents', 'Home')));
+        }
+    }
+    else {
+        vendorRoots.push('/usr/lib/jvm', '/usr/java', '/opt/java');
+    }
+    vendorRoots.push(join(home, '.jdks'), join(home, '.sdkman', 'candidates', 'java'));
+    for (const root of vendorRoots)
+        for (const d of subdirs(root))
+            out.push(bin(d));
+    return [...new Set(out)];
+}
+export function probeJava(path) {
+    return new Promise((resolve) => {
+        execFile(path, ['-version'], { timeout: 15_000, windowsHide: true }, (err, stdout, stderr) => {
+            if (err && !stderr)
+                return resolve(null);
+            const v = parseJavaVersion(`${stderr}\n${stdout}`);
+            resolve(v ? { path, ...v } : null);
+        });
+    });
+}
+export async function findJava(extra = [], env = process.env, home = homedir()) {
+    const paths = [...extra, ...candidatePaths(env, home)].filter((p) => existsSync(p));
+    const found = await Promise.all(paths.map(probeJava));
+    const seen = new Set();
+    return found.filter((j) => {
+        if (!j || seen.has(j.path.toLowerCase()))
+            return false;
+        seen.add(j.path.toLowerCase());
+        return true;
+    });
+}
+/** The best Java for a required major version: the exact version if present, otherwise the lowest newer one. */
+export function pickJava(found, major) {
+    const ok = found.filter((j) => j.major >= major).sort((a, b) => a.major - b.major);
+    return ok.find((j) => j.major === major) ?? ok[0] ?? null;
+}

package/dist/mc/properties.js

@@ -0,0 +1,149 @@
+import { randomBytes } from 'node:crypto';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { isLoopback, RCON_HOST } from '../safety/address.js';
+export class PropertiesError extends Error {
+}
+/** Java's whitespace in properties files: space, tab and form feed. */
+const SPACE = new Set([' ', '\t', '\f']);
+const ESCAPES = { t: '\t', n: '\n', r: '\r', f: '\f' };
+function unescape(s, line) {
+    let out = '';
+    for (let i = 0; i < s.length; i++) {
+        const c = s[i];
+        if (c !== '\\' || i + 1 >= s.length) {
+            out += c;
+            continue;
+        }
+        const n = s[++i];
+        if (n === 'u') {
+            const hex = s.slice(i + 1, i + 5);
+            if (!/^[0-9a-fA-F]{4}$/.test(hex))
+                throw new PropertiesError(`server.properties line ${line} has a broken \\u escape, so Minecraft cannot read the file either. Fix that line.`);
+            out += String.fromCharCode(parseInt(hex, 16));
+            i += 4;
+        }
+        else
+            out += ESCAPES[n] ?? n;
+    }
+    return out;
+}
+function escape(s) {
+    return s.replace(/\\/g, '\\\\').replace(/([:=#!])/g, '\\$1').replace(/^ /, '\\ ');
+}
+function skipSpace(s) {
+    let i = 0;
+    while (i < s.length && SPACE.has(s[i]))
+        i++;
+    return s.slice(i);
+}
+function continues(s) {
+    let n = 0;
+    while (n < s.length && s[s.length - 1 - n] === '\\')
+        n++;
+    return n % 2 === 1;
+}
+function entries(lines) {
+    const out = [];
+    for (let i = 0; i < lines.length; i++) {
+        let part = skipSpace(lines[i]);
+        if (part === '' || part[0] === '#' || part[0] === '!')
+            continue;
+        const first = i;
+        let text = '';
+        while (continues(part) && i + 1 < lines.length) {
+            text += part.slice(0, -1);
+            part = skipSpace(lines[++i]);
+        }
+        text += continues(part) ? part.slice(0, -1) : part;
+        // The key ends at the first unescaped =, : or whitespace; after whitespace one = or : may follow.
+        let k = 0;
+        let valueStart = text.length;
+        let hasSep = false;
+        let escaped = false;
+        for (; k < text.length; k++) {
+            const c = text[k];
+            if (!escaped && (c === '=' || c === ':' || SPACE.has(c))) {
+                hasSep = !SPACE.has(c);
+                valueStart = k + 1;
+                break;
+            }
+            escaped = c === '\\' ? !escaped : false;
+        }
+        while (valueStart < text.length) {
+            const c = text[valueStart];
+            if (!SPACE.has(c)) {
+                if (hasSep || (c !== '=' && c !== ':'))
+                    break;
+                hasSep = true;
+            }
+            valueStart++;
+        }
+        out.push({ key: unescape(text.slice(0, k), first + 1), value: unescape(text.slice(valueStart), first + 1), first, last: i });
+    }
+    return out;
+}
+const physicalLines = (text) => text.split(/\r\n|\r|\n/);
+export function parseProperties(text) {
+    const out = new Map();
+    for (const e of entries(physicalLines(text)))
+        out.set(e.key, e.value);
+    return out;
+}
+export function updateProperties(text, changes) {
+    const lines = physicalLines(text);
+    const left = new Map(Object.entries(changes));
+    for (const e of entries(lines)) {
+        if (!Object.hasOwn(changes, e.key))
+            continue;
+        lines[e.first] = `${e.key}=${escape(changes[e.key])}`;
+        for (let i = e.first + 1; i <= e.last; i++)
+            lines[i] = null;
+        left.delete(e.key);
+    }
+    const kept = lines.filter((l) => l !== null);
+    while (kept.length && kept[kept.length - 1] === '')
+        kept.pop();
+    for (const [k, v] of left)
+        kept.push(`${k}=${escape(v)}`);
+    return `${kept.join('\n')}\n`;
+}
+export function propertiesFile(serverDir) {
+    return join(serverDir, 'server.properties');
+}
+export function readProperties(serverDir) {
+    const f = propertiesFile(serverDir);
+    return existsSync(f) ? parseProperties(readFileSync(f, 'utf8')) : new Map();
+}
+export function newPassword() {
+    return randomBytes(24).toString('base64url');
+}
+/** Settings the tool always keeps: local only, RCON on, no query port, no RCON echo to players. */
+export function lockedChanges(props, rconPort) {
+    const pw = props.get('rcon.password') ?? '';
+    const management = props.get('management-server-host');
+    return {
+        'server-ip': isLoopback(props.get('server-ip') ?? '') ? props.get('server-ip') : RCON_HOST,
+        'enable-rcon': 'true',
+        'rcon.port': String(rconPort),
+        'rcon.password': pw.length >= 20 ? pw : newPassword(),
+        'enable-query': 'false',
+        'broadcast-rcon-to-ops': 'false',
+        // Minecraft 1.21.9 and newer has a management server, off by default; when it is set up it stays local too.
+        ...(management !== undefined && !isLoopback(management) ? { 'management-server-host': RCON_HOST } : {}),
+    };
+}
+/** Rewrites the locked settings if anything changed them. Returns the keys it had to fix. */
+export function enforceLocked(serverDir, rconPort) {
+    const f = propertiesFile(serverDir);
+    const text = existsSync(f) ? readFileSync(f, 'utf8') : '';
+    const props = parseProperties(text);
+    const changes = lockedChanges(props, rconPort);
+    const fixed = Object.entries(changes).filter(([k, v]) => props.get(k) !== v).map(([k]) => k);
+    if (fixed.length)
+        writeFileSync(f, updateProperties(text, changes));
+    return fixed;
+}
+export function redactProperties(text) {
+    return text.replace(/^(\s*(?:rcon\.password|management-server-secret)\s*[=:]).*$/gm, '$1<hidden>');
+}

package/dist/mc/setup.js

@@ -0,0 +1,167 @@
+import { execFile } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { existsSync, mkdirSync, readdirSync, rmSync, writeFileSync } from 'node:fs';
+import { basename, isAbsolute, join } from 'node:path';
+import { checkAllowedFolder } from '../safety/paths.js';
+import { downloadFile } from './download.js';
+import { findJava, javaInstallHint, pickJava } from './java.js';
+import { newPassword, updateProperties } from './properties.js';
+import { findFreePort, portFree, STATE_DIR, writeEula, writeMeta } from './testserver.js';
+import { EULA_URL, neoforgeSha256, resolveNeoForge, resolveVersion, serverDownload } from './versions.js';
+const PLAN_LIFETIME_MS = 30 * 60_000;
+const NAME = /^[A-Za-z0-9][A-Za-z0-9_-]{0,39}$/;
+export class SetupError extends Error {
+}
+/**
+ * A Java the agent names must be a program called java (java.exe) given by full path, and not inside
+ * a server folder: the file tools can write there, and the tool runs this program.
+ */
+export function checkJavaPath(config, path) {
+    const name = basename(path).toLowerCase();
+    if (!isAbsolute(path) || (name !== 'java' && name !== 'java.exe'))
+        throw new SetupError(`java_path must be the full path of a program called java or java.exe, not ${path}`);
+    let inServerFolder = true;
+    try {
+        checkAllowedFolder(config.serverFolders, path);
+    }
+    catch {
+        inServerFolder = false;
+    }
+    if (inServerFolder)
+        throw new SetupError(`java_path cannot be inside a server folder: ${path}. Use a Java installed on this computer.`);
+}
+export async function planSetup(config, input) {
+    if (!NAME.test(input.name))
+        throw new SetupError('Server name: 1-40 characters of A-Z a-z 0-9 _ -, starting with a letter or digit');
+    const root = input.serverFolder ?? config.serverFolders[0];
+    checkAllowedFolder(config.serverFolders, root);
+    const folder = checkAllowedFolder(config.serverFolders, join(root, input.name));
+    if (existsSync(folder) && readdirSync(folder).length > 0)
+        throw new SetupError(`${folder} already exists and is not empty. Pick another name, or use_server to use it.`);
+    if (input.javaPath)
+        checkJavaPath(config, input.javaPath);
+    const entry = await resolveVersion(input.minecraft);
+    const server = await serverDownload(entry);
+    const downloads = [];
+    let loaderVersion;
+    let loaderIsBeta;
+    if (input.loader === 'vanilla') {
+        downloads.push({ what: `Minecraft ${entry.id} server`, url: server.url, source: 'Mojang (official version manifest)', hash: { algo: 'sha1', value: server.sha1 }, size: server.size });
+    }
+    else {
+        const build = await resolveNeoForge(entry.id);
+        loaderVersion = build.version;
+        loaderIsBeta = build.beta;
+        downloads.push({ what: `NeoForge ${build.version} installer`, url: build.installerUrl, source: 'NeoForged (maven.neoforged.net)', hash: { algo: 'sha256', value: await neoforgeSha256(build) } });
+        downloads.push({ what: `Minecraft ${entry.id} server and NeoForge libraries, fetched and hash-checked by the NeoForge installer`, url: 'https://piston-data.mojang.com and https://maven.neoforged.net', source: 'Mojang and NeoForged', hash: { algo: 'sha1', value: server.sha1 } });
+    }
+    const extra = [input.javaPath, config.javaPath].filter((p) => !!p);
+    const javaFound = await findJava(extra);
+    const java = input.javaPath ? javaFound.find((j) => j.path === input.javaPath && j.major >= server.javaMajor) ?? null : pickJava(javaFound, server.javaMajor);
+    const gamePort = input.gamePort ?? (await findFreePort(25565));
+    const rconPort = input.rconPort ?? (await findFreePort(25575, [gamePort]));
+    if (gamePort === rconPort)
+        throw new SetupError('Game port and RCON port must differ');
+    return {
+        planId: randomUUID(),
+        folder,
+        minecraft: entry.id,
+        loader: input.loader,
+        ...(loaderVersion ? { loaderVersion, loaderIsBeta } : {}),
+        javaNeeded: server.javaMajor,
+        java,
+        javaFound,
+        ...(java ? {} : { javaMissing: javaInstallHint(server.javaMajor) }),
+        downloads,
+        gamePort,
+        rconPort,
+        memoryMb: input.memoryMb ?? (input.loader === 'neoforge' ? 4096 : 2048),
+        worldType: input.worldType ?? 'flat',
+        eulaUrl: EULA_URL,
+        ready: java !== null,
+        expires: Date.now() + PLAN_LIFETIME_MS,
+    };
+}
+export function serverProperties(plan) {
+    return updateProperties('#Minecraft server properties, made by Stonecut Map Builder\n', {
+        'server-ip': '127.0.0.1',
+        'server-port': String(plan.gamePort),
+        'enable-rcon': 'true',
+        'rcon.port': String(plan.rconPort),
+        'rcon.password': newPassword(),
+        'broadcast-rcon-to-ops': 'false',
+        'enable-query': 'false',
+        'online-mode': 'true',
+        motd: 'Stonecut test server (this computer only)',
+        gamemode: 'creative',
+        difficulty: 'peaceful',
+        'level-type': plan.worldType === 'flat' ? 'minecraft:flat' : 'minecraft:normal',
+        'generate-structures': plan.worldType === 'flat' ? 'false' : 'true',
+        'spawn-protection': '0',
+        'max-players': '8',
+        'enable-command-block': 'true',
+        'allow-flight': 'true',
+    });
+}
+function run(java, args, cwd, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        execFile(java, args, { cwd, timeout: timeoutMs, windowsHide: true, maxBuffer: 64 * 1024 * 1024 }, (err, stdout, stderr) => {
+            const out = `${stdout}\n${stderr}`;
+            if (err)
+                reject(new SetupError(`${err.message}\n${out.split(/\r?\n/).slice(-20).join('\n')}`));
+            else
+                resolve(out);
+        });
+    });
+}
+export async function createServer(plan) {
+    const began = Date.now();
+    if (Date.now() > plan.expires)
+        throw new SetupError('This plan has expired. Run plan_setup again and show the person the new plan.');
+    if (!plan.java)
+        throw new SetupError(`Java ${plan.javaNeeded} or newer is needed and was not found. Show the person: ${plan.javaMissing?.join('; ')}`);
+    if (existsSync(plan.folder) && readdirSync(plan.folder).length > 0)
+        throw new SetupError(`${plan.folder} is no longer empty`);
+    for (const p of [plan.gamePort, plan.rconPort])
+        if (!(await portFree(p)))
+            throw new SetupError(`Port ${p} is now in use; run plan_setup again`);
+    mkdirSync(join(plan.folder, STATE_DIR, 'downloads'), { recursive: true });
+    const downloaded = [];
+    let launch;
+    if (plan.loader === 'vanilla') {
+        const d = plan.downloads[0];
+        const r = await downloadFile(d.url, join(plan.folder, 'server.jar'), { algo: d.hash.algo, hash: d.hash.value, ...(d.size ? { size: d.size } : {}) });
+        downloaded.push({ what: d.what, ...r });
+        launch = { type: 'jar', jar: 'server.jar' };
+    }
+    else {
+        const d = plan.downloads[0];
+        const installer = join(plan.folder, STATE_DIR, 'downloads', 'neoforge-installer.jar');
+        const r = await downloadFile(d.url, installer, { algo: d.hash.algo, hash: d.hash.value });
+        downloaded.push({ what: d.what, ...r });
+        const out = await run(plan.java.path, ['-jar', installer, '--installServer', plan.folder], join(plan.folder, STATE_DIR, 'downloads'), 20 * 60_000);
+        writeFileSync(join(plan.folder, STATE_DIR, 'install.log'), out);
+        rmSync(installer, { force: true });
+        const artifact = plan.minecraft === '1.20.1' ? 'forge' : 'neoforge';
+        const libDir = `libraries/net/neoforged/${artifact}/${plan.loaderVersion}`;
+        if (!existsSync(join(plan.folder, libDir)))
+            throw new SetupError(`The NeoForge installer finished but ${libDir} is missing. See ${STATE_DIR}/install.log.`);
+        launch = { type: 'argfile', libDir };
+    }
+    writeFileSync(join(plan.folder, 'server.properties'), serverProperties(plan));
+    writeEula(plan.folder, false);
+    const meta = {
+        minecraft: plan.minecraft,
+        loader: plan.loader,
+        ...(plan.loaderVersion ? { loaderVersion: plan.loaderVersion } : {}),
+        javaPath: plan.java.path,
+        javaMajor: plan.java.major,
+        memoryMb: plan.memoryMb,
+        launch,
+        rconPort: plan.rconPort,
+        createdAt: new Date().toISOString(),
+        createdByTool: true,
+    };
+    writeMeta(plan.folder, meta);
+    return { folder: plan.folder, meta, downloaded, seconds: (Date.now() - began) / 1000 };
+}