stonecut-map-builder 0.0.0-stage → 0.1.1

package/dist/nbt/nbt.js

@@ -0,0 +1,282 @@
+import { gunzipSync, gzipSync, inflateSync } from 'node:zlib';
+const IDS = [
+    'end', 'byte', 'short', 'int', 'long', 'float', 'double', 'byteArray', 'string', 'list', 'compound', 'intArray', 'longArray',
+];
+const MAX_DEPTH = 512;
+export const nbt = {
+    byte: (value) => ({ type: 'byte', value }),
+    short: (value) => ({ type: 'short', value }),
+    int: (value) => ({ type: 'int', value }),
+    long: (value) => ({ type: 'long', value }),
+    float: (value) => ({ type: 'float', value }),
+    double: (value) => ({ type: 'double', value }),
+    string: (value) => ({ type: 'string', value }),
+    byteArray: (value) => ({ type: 'byteArray', value }),
+    intArray: (value) => ({ type: 'intArray', value: Int32Array.from(value) }),
+    longArray: (value) => ({ type: 'longArray', value }),
+    list: (itemType, value) => ({ type: 'list', itemType: value.length ? value[0].type : itemType, value }),
+    compound: (entries) => ({
+        type: 'compound',
+        value: entries instanceof Map ? entries : new Map(Object.entries(entries)),
+    }),
+};
+export class NbtError extends Error {
+}
+// ---- modified UTF-8 ----
+export function encodeModifiedUtf8(s) {
+    const out = [];
+    for (let i = 0; i < s.length; i++) {
+        const c = s.charCodeAt(i);
+        if (c !== 0 && c < 0x80)
+            out.push(c);
+        else if (c < 0x800)
+            out.push(0xc0 | (c >> 6), 0x80 | (c & 0x3f));
+        else
+            out.push(0xe0 | (c >> 12), 0x80 | ((c >> 6) & 0x3f), 0x80 | (c & 0x3f));
+    }
+    return Buffer.from(out);
+}
+export function decodeModifiedUtf8(b) {
+    let s = '';
+    for (let i = 0; i < b.length;) {
+        const a = b[i];
+        if (a < 0x80) {
+            s += String.fromCharCode(a);
+            i += 1;
+        }
+        else if ((a & 0xe0) === 0xc0) {
+            s += String.fromCharCode(((a & 0x1f) << 6) | (b[i + 1] & 0x3f));
+            i += 2;
+        }
+        else {
+            s += String.fromCharCode(((a & 0x0f) << 12) | ((b[i + 1] & 0x3f) << 6) | (b[i + 2] & 0x3f));
+            i += 3;
+        }
+    }
+    return s;
+}
+// ---- reading ----
+class Reader {
+    buf;
+    tagsLeft;
+    pos = 0;
+    /** tagsLeft limits the tags read: millions of tiny tags take far more memory than the bytes they come from. */
+    constructor(buf, tagsLeft) {
+        this.buf = buf;
+        this.tagsLeft = tagsLeft;
+    }
+    need(n) {
+        if (n < 0 || this.pos + n > this.buf.length)
+            throw new NbtError('NBT data ends too early');
+    }
+    u8() { this.need(1); return this.buf.readUInt8(this.pos++); }
+    i8() { this.need(1); return this.buf.readInt8(this.pos++); }
+    i16() { this.need(2); const v = this.buf.readInt16BE(this.pos); this.pos += 2; return v; }
+    u16() { this.need(2); const v = this.buf.readUInt16BE(this.pos); this.pos += 2; return v; }
+    i32() { this.need(4); const v = this.buf.readInt32BE(this.pos); this.pos += 4; return v; }
+    i64() { this.need(8); const v = this.buf.readBigInt64BE(this.pos); this.pos += 8; return v; }
+    f32() { this.need(4); const v = this.buf.readFloatBE(this.pos); this.pos += 4; return v; }
+    f64() { this.need(8); const v = this.buf.readDoubleBE(this.pos); this.pos += 8; return v; }
+    str() {
+        const n = this.u16();
+        this.need(n);
+        const s = decodeModifiedUtf8(this.buf.subarray(this.pos, this.pos + n));
+        this.pos += n;
+        return s;
+    }
+    count(width) {
+        const n = this.i32();
+        if (n < 0)
+            throw new NbtError('Negative NBT array length');
+        this.need(n * width);
+        return n;
+    }
+    payload(type, depth) {
+        if (depth > MAX_DEPTH)
+            throw new NbtError('NBT nested too deeply');
+        if (--this.tagsLeft < 0)
+            throw new NbtError('NBT data has too many tags');
+        switch (type) {
+            case 'byte': return { type, value: this.i8() };
+            case 'short': return { type, value: this.i16() };
+            case 'int': return { type, value: this.i32() };
+            case 'long': return { type, value: this.i64() };
+            case 'float': return { type, value: this.f32() };
+            case 'double': return { type, value: this.f64() };
+            case 'string': return { type, value: this.str() };
+            case 'byteArray': {
+                const n = this.count(1);
+                const value = new Int8Array(n);
+                for (let i = 0; i < n; i++)
+                    value[i] = this.i8();
+                return { type, value };
+            }
+            case 'intArray': {
+                const n = this.count(4);
+                const value = new Int32Array(n);
+                for (let i = 0; i < n; i++)
+                    value[i] = this.i32();
+                return { type, value };
+            }
+            case 'longArray': {
+                const n = this.count(8);
+                const value = new BigInt64Array(n);
+                for (let i = 0; i < n; i++)
+                    value[i] = this.i64();
+                return { type, value };
+            }
+            case 'list': {
+                const itemType = tagType(this.u8());
+                const n = this.count(0);
+                if (itemType === 'end' && n > 0)
+                    throw new NbtError('List of end tags');
+                const value = [];
+                for (let i = 0; i < n; i++)
+                    value.push(this.payload(itemType, depth + 1));
+                return { type, itemType, value };
+            }
+            case 'compound': {
+                const value = new Map();
+                for (;;) {
+                    const id = tagType(this.u8());
+                    if (id === 'end')
+                        break;
+                    const name = this.str();
+                    value.set(name, this.payload(id, depth + 1));
+                }
+                return { type, value };
+            }
+            case 'end':
+                throw new NbtError('Unexpected end tag');
+        }
+    }
+}
+function tagType(id) {
+    const t = IDS[id];
+    if (!t)
+        throw new NbtError(`Unknown NBT tag id ${id}`);
+    return t;
+}
+/** Reads one named root compound from uncompressed NBT bytes. */
+export function readNbt(buf, maxTags = Infinity) {
+    const r = new Reader(buf, maxTags);
+    const id = tagType(r.u8());
+    if (id !== 'compound')
+        throw new NbtError('NBT root is not a compound');
+    const name = r.str();
+    return { name, tag: r.payload('compound', 0) };
+}
+/** Accepts gzip, zlib or uncompressed NBT, up to maxBytes once unpacked and maxTags tags. */
+export function unpackNbt(buf, maxBytes = 512 * 1024 * 1024, maxTags = Infinity) {
+    let raw = buf;
+    if (buf[0] === 0x1f && buf[1] === 0x8b)
+        raw = gunzipSync(buf, { maxOutputLength: maxBytes });
+    else if (buf[0] === 0x78)
+        raw = inflateSync(buf, { maxOutputLength: maxBytes });
+    if (raw.length > maxBytes)
+        throw new NbtError(`NBT data is over ${maxBytes} bytes`);
+    return readNbt(raw, maxTags);
+}
+// ---- writing ----
+class Writer {
+    chunks = [];
+    bytes(b) { this.chunks.push(b); }
+    u8(v) { const b = Buffer.alloc(1); b.writeUInt8(v); this.bytes(b); }
+    i8(v) { const b = Buffer.alloc(1); b.writeInt8(v); this.bytes(b); }
+    i16(v) { const b = Buffer.alloc(2); b.writeInt16BE(v); this.bytes(b); }
+    i32(v) { const b = Buffer.alloc(4); b.writeInt32BE(v); this.bytes(b); }
+    i64(v) { const b = Buffer.alloc(8); b.writeBigInt64BE(v); this.bytes(b); }
+    str(s) {
+        const b = encodeModifiedUtf8(s);
+        if (b.length > 0xffff)
+            throw new NbtError('NBT string too long');
+        const len = Buffer.alloc(2);
+        len.writeUInt16BE(b.length);
+        this.bytes(len);
+        this.bytes(b);
+    }
+    payload(tag) {
+        switch (tag.type) {
+            case 'byte': return this.i8(tag.value);
+            case 'short': return this.i16(tag.value);
+            case 'int': return this.i32(tag.value);
+            case 'long': return this.i64(tag.value);
+            case 'float': {
+                const b = Buffer.alloc(4);
+                b.writeFloatBE(tag.value);
+                return this.bytes(b);
+            }
+            case 'double': {
+                const b = Buffer.alloc(8);
+                b.writeDoubleBE(tag.value);
+                return this.bytes(b);
+            }
+            case 'string': return this.str(tag.value);
+            case 'byteArray':
+                this.i32(tag.value.length);
+                return this.bytes(Buffer.from(tag.value.buffer, tag.value.byteOffset, tag.value.length));
+            case 'intArray': {
+                this.i32(tag.value.length);
+                const b = Buffer.alloc(tag.value.length * 4);
+                tag.value.forEach((v, i) => b.writeInt32BE(v, i * 4));
+                return this.bytes(b);
+            }
+            case 'longArray': {
+                this.i32(tag.value.length);
+                const b = Buffer.alloc(tag.value.length * 8);
+                tag.value.forEach((v, i) => b.writeBigInt64BE(v, i * 8));
+                return this.bytes(b);
+            }
+            case 'list': {
+                const itemType = tag.value.length ? tag.value[0].type : tag.itemType;
+                if (tag.value.some((t) => t.type !== itemType))
+                    throw new NbtError('NBT list items must share one type');
+                this.u8(IDS.indexOf(itemType));
+                this.i32(tag.value.length);
+                for (const t of tag.value)
+                    this.payload(t);
+                return;
+            }
+            case 'compound':
+                for (const [name, t] of tag.value) {
+                    this.u8(IDS.indexOf(t.type));
+                    this.str(name);
+                    this.payload(t);
+                }
+                return this.u8(0);
+        }
+    }
+    done() { return Buffer.concat(this.chunks); }
+}
+export function writeNbt(name, root) {
+    const w = new Writer();
+    w.u8(IDS.indexOf('compound'));
+    w.str(name);
+    w.payload(root);
+    return w.done();
+}
+export function packNbt(name, root) {
+    return gzipSync(writeNbt(name, root));
+}
+// ---- small accessors ----
+export function get(c, key, type) {
+    const t = c.value.get(key);
+    return t && t.type === type ? t : undefined;
+}
+export function need(c, key, type, where) {
+    const t = get(c, key, type);
+    if (!t)
+        throw new NbtError(`${where}: missing ${type} "${key}"`);
+    return t;
+}
+/** Reads a number from any numeric tag (schematic writers differ on short vs int). */
+export function num(c, key) {
+    const t = c.value.get(key);
+    if (!t)
+        return undefined;
+    if (t.type === 'byte' || t.type === 'short' || t.type === 'int' || t.type === 'float' || t.type === 'double')
+        return t.value;
+    if (t.type === 'long')
+        return Number(t.value);
+    return undefined;
+}

package/dist/nbt/snbt.js

@@ -0,0 +1,36 @@
+// Stringified NBT, the text form commands such as /setblock accept.
+const BARE_KEY = /^[A-Za-z0-9._+-]+$/;
+export class SnbtError extends Error {
+}
+function quote(s) {
+    if (/[\u0000-\u001f\u007f]/.test(s))
+        throw new SnbtError('Text with control characters cannot go into a command');
+    return `"${s.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+}
+function decimal(v, suffix) {
+    if (!Number.isFinite(v))
+        throw new SnbtError('NaN or infinite number cannot go into a command');
+    const s = String(v);
+    return `${/[.eE]/.test(s) ? s : `${s}.0`}${suffix}`;
+}
+export function toSnbt(tag) {
+    switch (tag.type) {
+        case 'byte': return `${tag.value}b`;
+        case 'short': return `${tag.value}s`;
+        case 'int': return String(tag.value);
+        case 'long': return `${tag.value}L`;
+        case 'float': return decimal(tag.value, 'f');
+        case 'double': return decimal(tag.value, 'd');
+        case 'string': return quote(tag.value);
+        case 'byteArray': return `[B;${Array.from(tag.value, (v) => `${v}b`).join(',')}]`;
+        case 'intArray': return `[I;${Array.from(tag.value).join(',')}]`;
+        case 'longArray': return `[L;${Array.from(tag.value, (v) => `${v}L`).join(',')}]`;
+        case 'list': return `[${tag.value.map(toSnbt).join(',')}]`;
+        case 'compound': {
+            const parts = [];
+            for (const [k, v] of tag.value)
+                parts.push(`${BARE_KEY.test(k) ? k : quote(k)}:${toSnbt(v)}`);
+            return `{${parts.join(',')}}`;
+        }
+    }
+}

package/dist/ops/backup.js

@@ -0,0 +1,69 @@
+import { existsSync, mkdirSync, readdirSync, renameSync, statSync } from 'node:fs';
+import { cp } from 'node:fs/promises';
+import { basename, join } from 'node:path';
+import { STATE_DIR } from '../mc/testserver.js';
+// Whole-world copies in the server's own folder. Nothing here deletes a world: restoring moves the
+// current world aside first.
+export class BackupError extends Error {
+}
+function stamp() {
+    return new Date().toISOString().replace(/[:.]/g, '-').replace('Z', '');
+}
+export function backupsDir(server) {
+    return join(server.dir, STATE_DIR, 'backups');
+}
+function folderBytes(dir) {
+    let total = 0;
+    for (const d of readdirSync(dir, { withFileTypes: true })) {
+        const p = join(dir, d.name);
+        total += d.isDirectory() ? folderBytes(p) : statSync(p).size;
+    }
+    return total;
+}
+export function listBackups(server) {
+    const dir = backupsDir(server);
+    if (!existsSync(dir))
+        return [];
+    return readdirSync(dir)
+        .filter((n) => existsSync(join(dir, n, 'level.dat')))
+        .sort()
+        .map((name) => ({ name, bytes: folderBytes(join(dir, name)) }));
+}
+const copyWorld = (from, to) => cp(from, to, { recursive: true, filter: (src) => basename(src) !== 'session.lock' });
+export async function backupWorld(server, running) {
+    const began = Date.now();
+    const world = server.worldDir;
+    if (!existsSync(join(world, 'level.dat')))
+        throw new BackupError('There is no world yet; start the server once first');
+    const name = `world-${stamp()}`;
+    const dest = join(backupsDir(server), name);
+    mkdirSync(backupsDir(server), { recursive: true });
+    if (running) {
+        const c = await server.connection();
+        await c.command('save-off');
+        try {
+            await c.command('save-all flush');
+            await copyWorld(world, dest);
+        }
+        finally {
+            await c.command('save-on');
+        }
+    }
+    else {
+        await copyWorld(world, dest);
+    }
+    return { name, bytes: folderBytes(dest), seconds: (Date.now() - began) / 1000 };
+}
+export async function restoreWorld(server, name) {
+    if (!/^(world|replaced)-[0-9T-]+$/.test(name))
+        throw new BackupError('Use a backup name from status (world-...)');
+    const src = join(backupsDir(server), name);
+    if (!existsSync(join(src, 'level.dat')))
+        throw new BackupError(`No backup called ${name}`);
+    const world = server.worldDir;
+    const keptAs = `replaced-${stamp()}`;
+    if (existsSync(world))
+        renameSync(world, join(backupsDir(server), keptAs));
+    await copyWorld(src, world);
+    return { restored: name, previousWorldKeptAs: keptAs };
+}

package/dist/ops/files.js

@@ -0,0 +1,118 @@
+import { existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import { basename, dirname, join } from 'node:path';
+import { enforceLocked, parseProperties, redactProperties } from '../mc/properties.js';
+import { STATE_DIR } from '../mc/testserver.js';
+import { resolveInside, shown } from '../safety/paths.js';
+// Files inside the test server's folder only: datapacks, configs, mods. The tool's own state
+// folder, the world's chunk files and eula.txt are off limits, and code (mods, jars, libraries,
+// programs and the files that tell Java how to start) needs allowModInstall. The rules are checked
+// on the real path, after links and Windows short names (SERVER~1.PRO) are resolved.
+export class FileError extends Error {
+}
+const PROTECTED_NAMES = new Set(['level.dat', 'level.dat_old', 'session.lock', 'eula.txt']);
+const PROTECTED_EXT = /\.(mca|mcc)$/i;
+/** Code the server runs: mods, and the libraries NeoForge's launch files point at. */
+const CODE_FOLDERS = new Set(['mods', 'libraries']);
+/** Java argument files: they can make Java load any program. */
+const CODE_NAMES = new Set(['user_jvm_args.txt', 'win_args.txt', 'unix_args.txt']);
+const CODE_EXT = /\.(jar|dll|so|dylib|jnilib|exe|com|bat|cmd|ps1|sh)$/i;
+function resolve(server, rel) {
+    return resolveInside(server.dir, rel, { hidden: [STATE_DIR] });
+}
+export function listFiles(server, rel, depth, max = 500) {
+    const start = resolve(server, rel || '.');
+    if (!existsSync(start))
+        throw new FileError(`Nothing at ${rel}`);
+    const entries = [];
+    const walk = (dir, level) => {
+        for (const d of readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+            if (entries.length >= max)
+                return;
+            const full = join(dir, d.name);
+            if (dir === server.dir && d.name.toLowerCase() === STATE_DIR)
+                continue;
+            const st = lstatSync(full);
+            if (st.isSymbolicLink())
+                entries.push({ path: shown(server.dir, full), type: 'link' });
+            else if (st.isDirectory()) {
+                entries.push({ path: `${shown(server.dir, full)}/`, type: 'folder' });
+                if (level < depth)
+                    walk(full, level + 1);
+            }
+            else
+                entries.push({ path: shown(server.dir, full), type: 'file', bytes: st.size });
+        }
+    };
+    if (!statSync(start).isDirectory())
+        throw new FileError(`${rel} is a file; use read_file`);
+    walk(start, 1);
+    return { entries, truncated: entries.length >= max };
+}
+export function readServerFile(server, config, rel, encoding) {
+    const p = resolve(server, rel);
+    if (!existsSync(p) || !statSync(p).isFile())
+        throw new FileError(`No file at ${rel}`);
+    const size = statSync(p).size;
+    if (size > config.maxFileBytes)
+        throw new FileError(`${rel} is ${size} bytes, over the limit of ${config.maxFileBytes} (maxFileBytes in the config)`);
+    // The RCON password stays hidden in every file and either encoding (latin1 keeps the bytes as they are).
+    let text = readFileSync(p).toString('latin1');
+    const pw = rconPassword(server);
+    if (pw)
+        text = text.split(pw).join('<hidden>');
+    if (basename(p).toLowerCase() === 'server.properties')
+        text = redactProperties(text);
+    const content = Buffer.from(text, 'latin1').toString(encoding === 'base64' ? 'base64' : 'utf8');
+    return { path: shown(server.dir, p), bytes: size, content };
+}
+function rconPassword(server) {
+    try {
+        return server.password();
+    }
+    catch {
+        return null;
+    }
+}
+/** Mods, jars, libraries, programs and Java argument files. rel is relative to the server folder. */
+export function isCodeFile(rel) {
+    const parts = rel.toLowerCase().split(/[\\/]/).filter(Boolean);
+    return CODE_FOLDERS.has(parts[0] ?? '') || CODE_NAMES.has(parts[parts.length - 1] ?? '') || CODE_EXT.test(rel);
+}
+export function writeServerFile(server, config, rel, content, encoding, overwrite) {
+    if (!config.allowFileWrites)
+        throw new FileError('File writes are turned off (allowFileWrites is false in the config). The person can turn them on.');
+    const p = resolve(server, rel);
+    if (isCodeFile(shown(server.dir, p)) && !config.allowModInstall) {
+        throw new FileError('Adding or changing mods and other code (jars, libraries, programs, Java argument files) is turned off (allowModInstall is false in the config). Tell the person which mod you want and why; they can turn it on.');
+    }
+    const name = basename(p).toLowerCase();
+    if (PROTECTED_NAMES.has(name)) {
+        throw new FileError(name === 'eula.txt' ? 'eula.txt can only change through accept_eula, after the person accepts the EULA' : `${name} is part of the world and cannot be written`);
+    }
+    if (PROTECTED_EXT.test(name))
+        throw new FileError('World chunk files cannot be written; change blocks with the block tools');
+    const data = encoding === 'base64' ? Buffer.from(content, 'base64') : Buffer.from(content, 'utf8');
+    if (data.length > config.maxFileBytes)
+        throw new FileError(`That is ${data.length} bytes, over the limit of ${config.maxFileBytes} (maxFileBytes in the config)`);
+    const settings = name === 'server.properties' && dirname(p) === resolve(server, '.');
+    // Minecraft could not read a broken file and would fall back to its defaults; refuse it instead.
+    if (settings)
+        parseProperties(data.toString('utf8'));
+    const existed = existsSync(p);
+    if (existed && statSync(p).isDirectory())
+        throw new FileError(`${rel} is a folder`);
+    if (existed && !overwrite)
+        throw new FileError(`${rel} exists. Call again with overwrite: true to replace it.`);
+    mkdirSync(dirname(p), { recursive: true });
+    // Check again after making folders, in case a link appeared on the way.
+    resolve(server, rel);
+    writeFileSync(p, data);
+    let note;
+    if (settings) {
+        const fixed = enforceLocked(server.dir, server.meta.rconPort);
+        if (fixed.length)
+            note = `Kept these settings as the tool needs them (local only, RCON on): ${fixed.join(', ')}`;
+        note = `${note ? `${note}. ` : ''}Restart the server for changes to take effect.`;
+    }
+    return { path: shown(server.dir, p), bytes: data.length, created: !existed, ...(note ? { note } : {}) };
+}

package/dist/ops/readout.js

@@ -0,0 +1,100 @@
+import { isAir } from '../mc/blocks.js';
+import { nbt } from '../nbt/nbt.js';
+import { toSnbt } from '../nbt/snbt.js';
+import { uuidString } from '../mc/entities.js';
+// Turns an area into compact text for the agent: a palette, then one line per row of blocks
+// with repeats written as index*count.
+export function rle(values) {
+    const out = [];
+    for (let i = 0; i < values.length;) {
+        let j = i;
+        while (j < values.length && values[j] === values[i])
+            j++;
+        out.push(j - i > 1 ? `${values[i]}*${j - i}` : String(values[i]));
+        i = j;
+    }
+    return out.join(' ');
+}
+export function describeArea(read, box, format) {
+    const s = read.schematic;
+    const counts = new Map();
+    for (const i of s.blocks)
+        counts.set(s.palette[i], (counts.get(s.palette[i]) ?? 0) + 1);
+    const base = {
+        from: box.min,
+        to: box.max,
+        size: [s.width, s.height, s.length],
+        counts: Object.fromEntries([...counts.entries()].sort((a, b) => b[1] - a[1])),
+        block_entities: s.blockEntities.map((b) => ({ pos: [box.min[0] + b.pos[0], box.min[1] + b.pos[1], box.min[2] + b.pos[2]], id: b.id })),
+        ...(read.missingChunks.length ? { not_generated_chunks: read.missingChunks, note: 'Chunks that are not generated read as air.' } : {}),
+    };
+    if (format === 'list') {
+        const blocks = [];
+        for (let y = 0; y < s.height; y++)
+            for (let z = 0; z < s.length; z++)
+                for (let x = 0; x < s.width; x++) {
+                    const state = s.palette[s.blocks[x + z * s.width + y * s.width * s.length]];
+                    if (!isAir(state))
+                        blocks.push([box.min[0] + x, box.min[1] + y, box.min[2] + z, state]);
+                }
+        return { ...base, blocks };
+    }
+    const layers = [];
+    for (let y = 0; y < s.height; y++) {
+        const rows = [];
+        let allAir = true;
+        for (let z = 0; z < s.length; z++) {
+            const row = [];
+            for (let x = 0; x < s.width; x++) {
+                const v = s.blocks[x + z * s.width + y * s.width * s.length];
+                if (!isAir(s.palette[v]))
+                    allAir = false;
+                row.push(v);
+            }
+            rows.push(rle(row));
+        }
+        layers.push({ y: box.min[1] + y, rows: allAir ? 'all air' : rows });
+    }
+    return {
+        ...base,
+        palette: s.palette,
+        how_to_read: `Each layer is one y level. rows[0] is z=${box.min[2]}, the last is z=${box.max[2]}. Each row runs from x=${box.min[0]} to x=${box.max[0]} as palette indices; "3*5" means index 3 five times.`,
+        layers,
+    };
+}
+/** Fields every entity has that say little about it; left out of the short form. */
+const NOISE = new Set([
+    'Pos', 'UUID', 'Motion', 'Rotation', 'id', 'Brain', 'Air', 'Fire', 'fall_distance', 'FallDistance', 'OnGround', 'PortalCooldown',
+    'Invulnerable', 'HurtTime', 'HurtByTimestamp', 'DeathTime', 'AbsorptionAmount', 'FallFlying', 'attributes', 'Attributes',
+    'LeftHanded', 'CanPickUpLoot', 'PersistenceRequired', 'ForcedAge', 'InLove', 'Age',
+]);
+const round = (v) => Math.round(v * 1000) / 1000;
+export function describeEntities(list, box, full) {
+    return {
+        from: box.min,
+        to: box.max,
+        count: list.length,
+        entities: list.map((e) => {
+            const rot = e.data.value.get('Rotation');
+            const name = e.data.value.get('CustomName');
+            const leash = e.data.value.get('leash') ?? e.data.value.get('Leash');
+            const shown = full ? e.data : nbt.compound(new Map([...e.data.value].filter(([k]) => !NOISE.has(k))));
+            let text;
+            try {
+                text = toSnbt(shown);
+            }
+            catch {
+                text = '(data has text that cannot be shown as SNBT)';
+            }
+            return {
+                id: e.id,
+                pos: e.pos.map(round),
+                ...(rot?.type === 'list' ? { rotation: rot.value.map((t) => (t.type === 'float' ? round(t.value) : 0)) } : {}),
+                uuid: e.uuid ? uuidString(e.uuid) : null,
+                ...(name ? { name: name.type === 'string' ? name.value : toSnbt(name) } : {}),
+                ...(leash ? { leash: toSnbt(leash) } : {}),
+                nbt: full || text.length <= 600 ? text : `${text.slice(0, 600)}... (full: true for all of it)`,
+            };
+        }),
+    };
+}

package/dist/ops/undo.js

@@ -0,0 +1,45 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+export class UndoStore {
+    dir;
+    keep;
+    constructor(dir, keep) {
+        this.dir = dir;
+        this.keep = keep;
+    }
+    ids() {
+        if (!existsSync(this.dir))
+            return [];
+        return readdirSync(this.dir)
+            .map((f) => /^(\d+)\.json$/.exec(f)?.[1])
+            .filter((x) => !!x)
+            .map(Number)
+            .sort((a, b) => a - b);
+    }
+    list() {
+        return this.ids().map((id) => JSON.parse(readFileSync(join(this.dir, `${id}.json`), 'utf8')));
+    }
+    push(entry, schem) {
+        mkdirSync(this.dir, { recursive: true });
+        const ids = this.ids();
+        const id = (ids[ids.length - 1] ?? 0) + 1;
+        const full = { id, time: new Date().toISOString(), ...entry };
+        writeFileSync(join(this.dir, `${id}.schem`), schem);
+        writeFileSync(join(this.dir, `${id}.json`), `${JSON.stringify(full)}\n`);
+        for (const old of ids.slice(0, Math.max(0, ids.length + 1 - this.keep)))
+            this.remove(old);
+        return full;
+    }
+    latest() {
+        const ids = this.ids();
+        const id = ids[ids.length - 1];
+        if (id === undefined)
+            return null;
+        const entry = JSON.parse(readFileSync(join(this.dir, `${id}.json`), 'utf8'));
+        return { entry, schem: readFileSync(join(this.dir, `${id}.schem`)) };
+    }
+    remove(id) {
+        rmSync(join(this.dir, `${id}.schem`), { force: true });
+        rmSync(join(this.dir, `${id}.json`), { force: true });
+    }
+}