@lzimul/minecraft-mcp 1.0.4 → 1.0.5

package/build/tools/world-tools.js

@@ -1,8 +1,39 @@
 import * as z from 'zod/v4';
+import { WORLD_LIMITS } from '../config/world-limits.js';
+import { blockPositionShape } from '../schemas/coordinate-schema.js';
 import { dimensionField } from '../schemas/dimension-schema.js';
+import { entitySummarySchema, toEntitySummary } from '../schemas/entity-schema.js';
 import { toErrorMessage } from '../utils/error-message.js';
-import { toolError } from './result.js';
+import { formatStates, isEmptyStates, sameStates } from '../world/block-states.js';
+import { parseBlockSpec } from '../world/block-spec.js';
+import { SNAPSHOT_FORMAT } from '../world/stores/serialized-snapshot.js';
+import { coordinateRangeError, toolError } from './result.js';
 const blockStatesSchema = z.record(z.string(), z.string());
+const positionSchema = z.object({
+    x: z.number().int(),
+    y: z.number().int(),
+    z: z.number().int()
+});
+const blockTypeSchema = z
+    .string()
+    .trim()
+    .min(1)
+    .max(256)
+    .describe('Block id, such as "minecraft:stone" or "stone"; states are optional, for example "oak_stairs[facing=south]"');
+function normalizeArea(from, to) {
+    return {
+        from: {
+            x: Math.min(from.x, to.x),
+            y: Math.min(from.y, to.y),
+            z: Math.min(from.z, to.z)
+        },
+        to: {
+            x: Math.max(from.x, to.x),
+            y: Math.max(from.y, to.y),
+            z: Math.max(from.z, to.z)
+        }
+    };
+}
 export function registerWorldTools(server, world) {
     server.registerTool('getDimension', {
         title: 'Get Dimension',
@@ -136,4 +167,360 @@ export function registerWorldTools(server, world) {
             return toolError(`getDimensionBlocks failed: ${toErrorMessage(error)}`);
         }
     });
+    server.registerTool('getBlocksInArea', {
+        title: 'Get Blocks In Area',
+        description: 'List placed (non-air) blocks inside an inclusive box in one dimension, sorted by x, y and z. Corners may be supplied in any order. An optional blockType filter matches the block id and, when states are supplied, the exact state map. Results are paginated with limit and offset. Unmodified coordinates are air and are not listed.',
+        inputSchema: z.object({
+            dimension: dimensionField,
+            from: z.object(blockPositionShape),
+            to: z.object(blockPositionShape),
+            blockType: blockTypeSchema
+                .optional()
+                .describe('Optional block filter, such as "minecraft:oak_stairs" or "oak_stairs[facing=south]"'),
+            limit: z
+                .number()
+                .int()
+                .min(1)
+                .max(10_000)
+                .default(1_000)
+                .describe('Maximum number of matching blocks to return (1-10000, default 1000)'),
+            offset: z
+                .number()
+                .int()
+                .min(0)
+                .default(0)
+                .describe('Number of matching blocks to skip (default 0)')
+        }),
+        outputSchema: z.object({
+            dimension: z.string(),
+            displayName: z.string(),
+            from: positionSchema,
+            to: positionSchema,
+            blockType: z.string().nullable(),
+            total: z.number().int(),
+            offset: z.number().int(),
+            limit: z.number().int(),
+            returned: z.number().int(),
+            hasMore: z.boolean(),
+            blocks: z.array(z.object({
+                x: z.number().int(),
+                y: z.number().int(),
+                z: z.number().int(),
+                block: z.string(),
+                displayName: z.string(),
+                states: blockStatesSchema
+            }))
+        }),
+        annotations: {
+            readOnlyHint: true,
+            idempotentHint: true,
+            openWorldHint: false
+        }
+    }, async ({ dimension: dimensionType, from, to, blockType, limit, offset }) => {
+        try {
+            const dimension = world.getDimension(dimensionType);
+            if (!dimension.contains(from.x, from.y, from.z)) {
+                return coordinateRangeError(dimension.info, from.x, from.y, from.z);
+            }
+            if (!dimension.contains(to.x, to.y, to.z)) {
+                return coordinateRangeError(dimension.info, to.x, to.y, to.z);
+            }
+            const area = normalizeArea(from, to);
+            const spec = blockType ? parseBlockSpec(blockType) : null;
+            if (spec && !spec.ok) {
+                return toolError(spec.error);
+            }
+            const matches = dimension.sortedPlacedBlocks.filter(placed => {
+                if (placed.x < area.from.x ||
+                    placed.x > area.to.x ||
+                    placed.y < area.from.y ||
+                    placed.y > area.to.y ||
+                    placed.z < area.from.z ||
+                    placed.z > area.to.z) {
+                    return false;
+                }
+                if (!spec) {
+                    return true;
+                }
+                return (placed.block.key === spec.block.key &&
+                    (isEmptyStates(spec.states) ||
+                        sameStates(placed.states, spec.states)));
+            });
+            const total = matches.length;
+            const page = matches.slice(offset, offset + limit);
+            const returned = page.length;
+            const hasMore = offset + returned < total;
+            const filter = spec
+                ? `${spec.block.key}${formatStates(spec.states)}`
+                : null;
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Returned ${returned} of ${total} placed block(s) in ${dimension.info.displayName} from (${area.from.x}, ${area.from.y}, ${area.from.z}) to (${area.to.x}, ${area.to.y}, ${area.to.z})${filter ? ` matching ${filter}` : ''} (offset ${offset}, limit ${limit}${hasMore ? ', more available' : ''})`
+                    }
+                ],
+                structuredContent: {
+                    dimension: dimension.info.key,
+                    displayName: dimension.info.displayName,
+                    from: area.from,
+                    to: area.to,
+                    blockType: filter,
+                    total,
+                    offset,
+                    limit,
+                    returned,
+                    hasMore,
+                    blocks: page.map(placed => ({
+                        x: placed.x,
+                        y: placed.y,
+                        z: placed.z,
+                        block: placed.block.key,
+                        displayName: placed.block.displayName,
+                        states: placed.states
+                    }))
+                }
+            };
+        }
+        catch (error) {
+            return toolError(`getBlocksInArea failed: ${toErrorMessage(error)}`);
+        }
+    });
+    server.registerTool('fillBlocks', {
+        title: 'Fill Blocks',
+        description: 'Fill an inclusive box in one dimension with one block type and optional states. Corners may be supplied in any order. By default only air coordinates are filled; set overwrite to true to replace existing blocks. Use "minecraft:air" with overwrite to clear a region. The maximum volume per request is 16,384 blocks.',
+        inputSchema: z.object({
+            dimension: dimensionField,
+            from: z.object(blockPositionShape),
+            to: z.object(blockPositionShape),
+            blockType: blockTypeSchema,
+            overwrite: z
+                .boolean()
+                .default(false)
+                .describe('Replace existing non-air blocks when true; default false fills air only')
+        }),
+        outputSchema: z.object({
+            dimension: z.string(),
+            displayName: z.string(),
+            from: positionSchema,
+            to: positionSchema,
+            blockType: z.string(),
+            block: z.string(),
+            states: blockStatesSchema,
+            overwrite: z.boolean(),
+            volume: z.number().int(),
+            changed: z.number().int(),
+            placed: z.number().int(),
+            removed: z.number().int(),
+            skipped: z.number().int(),
+            modifiedBlockCount: z.number().int()
+        }),
+        annotations: {
+            destructiveHint: true,
+            idempotentHint: true,
+            openWorldHint: false
+        }
+    }, async ({ dimension: dimensionType, from, to, blockType, overwrite }) => {
+        try {
+            const dimension = world.getDimension(dimensionType);
+            if (!dimension.contains(from.x, from.y, from.z)) {
+                return coordinateRangeError(dimension.info, from.x, from.y, from.z);
+            }
+            if (!dimension.contains(to.x, to.y, to.z)) {
+                return coordinateRangeError(dimension.info, to.x, to.y, to.z);
+            }
+            const area = normalizeArea(from, to);
+            const volume = (area.to.x - area.from.x + 1) *
+                (area.to.y - area.from.y + 1) *
+                (area.to.z - area.from.z + 1);
+            if (!Number.isSafeInteger(volume) ||
+                volume > WORLD_LIMITS.maxFillVolume) {
+                return toolError(`The requested fill volume is too large (${volume}); the maximum is ${WORLD_LIMITS.maxFillVolume} blocks.`);
+            }
+            const spec = parseBlockSpec(blockType);
+            if (!spec.ok) {
+                return toolError(spec.error);
+            }
+            const isAirTarget = spec.block.key === 'minecraft:air';
+            if (isAirTarget && !isEmptyStates(spec.states)) {
+                return toolError('Air cannot carry block states. Use "minecraft:air" to remove blocks.');
+            }
+            let newBlocks = 0;
+            let skipped = 0;
+            for (let x = area.from.x; x <= area.to.x; x += 1) {
+                for (let y = area.from.y; y <= area.to.y; y += 1) {
+                    for (let z = area.from.z; z <= area.to.z; z += 1) {
+                        const existing = dimension.getBlockState(x, y, z);
+                        const existingIsAir = existing.block.key === 'minecraft:air';
+                        if (!overwrite && !existingIsAir) {
+                            skipped += 1;
+                            continue;
+                        }
+                        if (isAirTarget) {
+                            if (existingIsAir) {
+                                skipped += 1;
+                            }
+                            continue;
+                        }
+                        if (!existingIsAir &&
+                            existing.block.key === spec.block.key &&
+                            sameStates(existing.states, spec.states)) {
+                            skipped += 1;
+                            continue;
+                        }
+                        if (existingIsAir) {
+                            newBlocks += 1;
+                        }
+                    }
+                }
+            }
+            if (dimension.modifiedBlockCount + newBlocks >
+                WORLD_LIMITS.maxModifiedBlocks) {
+                return toolError(`The ${dimension.info.displayName} world would exceed the maximum of ${WORLD_LIMITS.maxModifiedBlocks} modified blocks.`);
+            }
+            let placed = 0;
+            let removed = 0;
+            let changed = 0;
+            for (let x = area.from.x; x <= area.to.x; x += 1) {
+                for (let y = area.from.y; y <= area.to.y; y += 1) {
+                    for (let z = area.from.z; z <= area.to.z; z += 1) {
+                        const existing = dimension.getBlockState(x, y, z);
+                        const existingIsAir = existing.block.key === 'minecraft:air';
+                        if (!overwrite && !existingIsAir) {
+                            continue;
+                        }
+                        if (isAirTarget) {
+                            if (!existingIsAir) {
+                                dimension.setBlock(x, y, z, spec.block, spec.states);
+                                removed += 1;
+                                changed += 1;
+                            }
+                            continue;
+                        }
+                        if (!existingIsAir &&
+                            existing.block.key === spec.block.key &&
+                            sameStates(existing.states, spec.states)) {
+                            continue;
+                        }
+                        dimension.setBlock(x, y, z, spec.block, spec.states);
+                        placed += 1;
+                        changed += 1;
+                    }
+                }
+            }
+            if (changed > 0) {
+                try {
+                    await dimension.flush();
+                }
+                catch (error) {
+                    return toolError(`The region was changed but could not be persisted to the world store: ${toErrorMessage(error)}`);
+                }
+            }
+            const normalizedType = `${spec.block.key}${formatStates(spec.states)}`;
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Filled ${changed} of ${volume} coordinate(s) in ${dimension.info.displayName} with ${normalizedType} (${placed} placed, ${removed} removed, ${skipped} skipped)`
+                    }
+                ],
+                structuredContent: {
+                    dimension: dimension.info.key,
+                    displayName: dimension.info.displayName,
+                    from: area.from,
+                    to: area.to,
+                    blockType: normalizedType,
+                    block: spec.block.key,
+                    states: spec.states,
+                    overwrite,
+                    volume,
+                    changed,
+                    placed,
+                    removed,
+                    skipped,
+                    modifiedBlockCount: dimension.modifiedBlockCount
+                }
+            };
+        }
+        catch (error) {
+            return toolError(`fillBlocks failed: ${toErrorMessage(error)}`);
+        }
+    });
+    server.registerTool('getDimensionEntities', {
+        title: 'Get Dimension Entities',
+        description: 'List every entity and player in one dimension, sorted by UUID. Each row contains the entity UUID, kind, type, display name, name, position and dimension. Use getEntity or getInventory for one entity and its full inventory.',
+        inputSchema: z.object({
+            dimension: dimensionField
+        }),
+        outputSchema: z.object({
+            dimension: z.string(),
+            displayName: z.string(),
+            entityCount: z.number().int(),
+            playerCount: z.number().int(),
+            entities: z.array(entitySummarySchema)
+        }),
+        annotations: {
+            readOnlyHint: true,
+            idempotentHint: true,
+            openWorldHint: false
+        }
+    }, async ({ dimension: dimensionType }) => {
+        try {
+            const dimension = world.getDimension(dimensionType);
+            const entities = dimension.sortedPlacedEntities.map(toEntitySummary);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `${dimension.info.displayName} (${dimension.info.key}) holds ${entities.length} entities and ${dimension.playerCount} players`
+                    }
+                ],
+                structuredContent: {
+                    dimension: dimension.info.key,
+                    displayName: dimension.info.displayName,
+                    entityCount: entities.length,
+                    playerCount: dimension.playerCount,
+                    entities
+                }
+            };
+        }
+        catch (error) {
+            return toolError(`getDimensionEntities failed: ${toErrorMessage(error)}`);
+        }
+    });
+    server.registerTool('getDimensionRawFile', {
+        title: 'Get Dimension Raw File',
+        description: 'Return the raw JSON snapshot of one dimension, including its top-level blocks and entities arrays. The result is the on-disk JSON for file storage, or the equivalent serialized state for memory storage, and can be loaded directly by minecraft_world_viewer.html.',
+        inputSchema: z.object({
+            dimension: dimensionField
+        }),
+        outputSchema: z.object({
+            dimension: z.string(),
+            format: z.string(),
+            bytes: z.number().int(),
+            raw: z.string()
+        }),
+        annotations: {
+            readOnlyHint: true,
+            idempotentHint: true,
+            openWorldHint: false
+        }
+    }, async ({ dimension: dimensionType }) => {
+        try {
+            const dimension = world.getDimension(dimensionType);
+            const raw = await dimension.readRaw();
+            return {
+                content: [{ type: 'text', text: raw }],
+                structuredContent: {
+                    dimension: dimension.info.key,
+                    format: SNAPSHOT_FORMAT,
+                    bytes: Buffer.byteLength(raw, 'utf8'),
+                    raw
+                }
+            };
+        }
+        catch (error) {
+            return toolError(`getDimensionRawFile failed: ${toErrorMessage(error)}`);
+        }
+    });
 }

package/build/utils/logger.js

@@ -16,7 +16,7 @@ const REQUESTED_LOG_LEVEL = process.env.MCP_LOG_LEVEL?.trim().toUpperCase();
 const LOG_LEVEL = REQUESTED_LOG_LEVEL && VALID_LOG_LEVELS.has(REQUESTED_LOG_LEVEL)
     ? REQUESTED_LOG_LEVEL
     : 'INFO';
-const LOGGER_CATEGORY = 'lzimul-minecraft-mcp';
+const LOGGER_CATEGORY = '@lzimul/minecraft-mcp';
 function chalkLayout(event) {
     const line = `${event.startTime.toISOString()} [${event.level.levelStr}] ${event.categoryName} - ${format(...event.data)}`;
     switch (event.level.levelStr) {

package/build/world/block-spec.js

@@ -26,6 +26,7 @@ export function parseBlockSpec(input) {
         };
     }
     const states = {};
+    let stateCount = 0;
     if (typeof rawStates === 'string') {
         if (rawStates.trim().length === 0) {
             return {
@@ -62,7 +63,8 @@ export function parseBlockSpec(input) {
                 };
             }
             states[propertyName] = propertyValue;
-            if (Object.keys(states).length > MAX_STATES) {
+            stateCount += 1;
+            if (stateCount > MAX_STATES) {
                 return {
                     ok: false,
                     error: `Too many block states in "${input}" (max ${MAX_STATES}).`

package/build/world/entity-inventory.js

@@ -74,11 +74,28 @@ export function sameItemStack(a, b) {
     return a !== null && b !== null && a.item === b.item && a.count === b.count;
 }
 export function inventoryUsedSlots(inventory) {
-    return (inventory.hotbar.filter(stack => stack !== null).length +
-        inventory.inventory.filter(stack => stack !== null).length);
+    let used = 0;
+    for (const stack of inventory.hotbar) {
+        if (stack !== null) {
+            used += 1;
+        }
+    }
+    for (const stack of inventory.inventory) {
+        if (stack !== null) {
+            used += 1;
+        }
+    }
+    return used;
 }
 export function sectionUsedSlots(inventory, section) {
-    return (section === EInventorySection.Hotbar
+    const slots = section === EInventorySection.Hotbar
         ? inventory.hotbar
-        : inventory.inventory).filter(stack => stack !== null).length;
+        : inventory.inventory;
+    let used = 0;
+    for (const stack of slots) {
+        if (stack !== null) {
+            used += 1;
+        }
+    }
+    return used;
 }

package/build/world/simulated-dimension.js

@@ -4,11 +4,30 @@ import { getBlockByName, MINECRAFT_BLOCKS } from '../data/blocks.js';
 import { getEntityTypeByName } from '../data/entities.js';
 import { EEntityKind } from '../enums/entity-kind.enum.js';
 import { EInventorySection } from '../enums/inventory-section.enum.js';
+import { EMoveDirection } from '../enums/move-direction.enum.js';
 import { toErrorMessage } from '../utils/error-message.js';
 import { logger } from '../utils/logger.js';
 import { EMPTY_BLOCK_STATES, isEmptyStates, normalizeStates, sameStates } from './block-states.js';
-import { createEmptyInventory, getInventorySlot, isSlotInRange, sameItemStack, slotCount, withInventorySlot } from './entity-inventory.js';
+import { createEmptyInventory, getInventorySlot, inventoryUsedSlots, isSlotInRange, sameItemStack, slotCount, withInventorySlot } from './entity-inventory.js';
 const AIR = getBlockByName('air') ?? MINECRAFT_BLOCKS[0];
+function directionDelta(direction) {
+    switch (direction) {
+        case EMoveDirection.Forward:
+            return { x: 0, y: 0, z: 1 };
+        case EMoveDirection.Back:
+            return { x: 0, y: 0, z: -1 };
+        case EMoveDirection.Left:
+            return { x: -1, y: 0, z: 0 };
+        case EMoveDirection.Right:
+            return { x: 1, y: 0, z: 0 };
+        case EMoveDirection.Up:
+            return { x: 0, y: 1, z: 0 };
+        case EMoveDirection.Down:
+            return { x: 0, y: -1, z: 0 };
+        default:
+            throw new Error(`Unknown movement direction "${direction}".`);
+    }
+}
 function coordinateKey(x, y, z) {
     return `${x},${y},${z}`;
 }
@@ -71,6 +90,12 @@ export class SimulatedDimension {
         return this.sortedEntitiesCache;
     }
     async load() {
+        if (this.timer !== null) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+        await this.queue;
+        this.dirty = false;
         const stored = await this.store.load(this.info.type);
         this.blocks.clear();
         this.entities.clear();
@@ -96,17 +121,19 @@ export class SimulatedDimension {
                 entity.dimension !== this.info.type;
             const overLimit = !duplicateId &&
                 this.entities.size >= WORLD_LIMITS.maxEntitiesPerDimension;
-            const playerName = entity.name.trim().toLowerCase();
-            const duplicatePlayer = entity.kind === EEntityKind.Player &&
-                this.playersByName.has(playerName);
-            if (duplicateId || outOfRange || overLimit || duplicatePlayer) {
+            if (duplicateId || outOfRange || overLimit) {
                 skippedEntities++;
                 continue;
             }
-            this.entities.set(entity.id, entity);
             if (entity.kind === EEntityKind.Player) {
+                const playerName = entity.name.trim().toLowerCase();
+                if (this.playersByName.has(playerName)) {
+                    skippedEntities++;
+                    continue;
+                }
                 this.playersByName.set(playerName, entity);
             }
+            this.entities.set(entity.id, entity);
         }
         if (skippedBlocks > 0) {
             logger.warn(`Skipped ${skippedBlocks} invalid block(s) while loading ${this.info.key}`);
@@ -229,6 +256,101 @@ export class SimulatedDimension {
         this.markDirty();
         return { previous, entity: updated };
     }
+    deleteEntity(id) {
+        const entity = this.entities.get(id);
+        if (!entity) {
+            return;
+        }
+        this.entities.delete(id);
+        if (entity.kind === EEntityKind.Player) {
+            this.playersByName.delete(entity.name.trim().toLowerCase());
+        }
+        this.sortedEntitiesCache = null;
+        this.markDirty();
+        return entity;
+    }
+    clearInventory(id) {
+        const entity = this.entities.get(id);
+        if (!entity) {
+            throw new RangeError(`Unknown entity "${id}" in ${this.info.displayName}.`);
+        }
+        const clearedSlots = inventoryUsedSlots(entity.inventory);
+        if (clearedSlots === 0) {
+            return { clearedSlots, entity };
+        }
+        const updated = {
+            ...entity,
+            inventory: createEmptyInventory()
+        };
+        this.entities.set(id, updated);
+        if (updated.kind === EEntityKind.Player) {
+            this.playersByName.set(updated.name.trim().toLowerCase(), updated);
+        }
+        this.sortedEntitiesCache = null;
+        this.markDirty();
+        return { clearedSlots, entity: updated };
+    }
+    swapInventorySlots(id, fromSection, fromSlot, toSection, toSlot) {
+        const entity = this.entities.get(id);
+        if (!entity) {
+            throw new RangeError(`Unknown entity "${id}" in ${this.info.displayName}.`);
+        }
+        if (!isSlotInRange(fromSection, fromSlot)) {
+            throw new RangeError(`Slot ${fromSlot} is out of range for the ${fromSection} (0-${slotCount(fromSection) - 1}).`);
+        }
+        if (!isSlotInRange(toSection, toSlot)) {
+            throw new RangeError(`Slot ${toSlot} is out of range for the ${toSection} (0-${slotCount(toSection) - 1}).`);
+        }
+        const previousFrom = getInventorySlot(entity.inventory, fromSection, fromSlot);
+        const previousTo = getInventorySlot(entity.inventory, toSection, toSlot);
+        const sameSlot = fromSection === toSection && fromSlot === toSlot;
+        if (sameSlot || sameItemStack(previousFrom, previousTo)) {
+            return { previousFrom, previousTo, entity };
+        }
+        let inventory = withInventorySlot(entity.inventory, fromSection, fromSlot, previousTo);
+        inventory = withInventorySlot(inventory, toSection, toSlot, previousFrom);
+        const updated = { ...entity, inventory };
+        this.entities.set(id, updated);
+        if (updated.kind === EEntityKind.Player) {
+            this.playersByName.set(updated.name.trim().toLowerCase(), updated);
+        }
+        this.sortedEntitiesCache = null;
+        this.markDirty();
+        return { previousFrom, previousTo, entity: updated };
+    }
+    moveEntity(id, direction) {
+        const entity = this.entities.get(id);
+        if (!entity) {
+            throw new RangeError(`Unknown entity "${id}" in ${this.info.displayName}.`);
+        }
+        const delta = directionDelta(direction);
+        return this.setEntityPosition(id, entity.x + delta.x, entity.y + delta.y, entity.z + delta.z);
+    }
+    setEntityPosition(id, x, y, z) {
+        const entity = this.entities.get(id);
+        if (!entity) {
+            throw new RangeError(`Unknown entity "${id}" in ${this.info.displayName}.`);
+        }
+        if (!this.contains(x, y, z)) {
+            throw new RangeError(`Position (${x}, ${y}, ${z}) is out of range in ${this.info.displayName} (Y: ${this.info.minY} to ${this.info.maxY - 1}).`);
+        }
+        const previous = {
+            x: entity.x,
+            y: entity.y,
+            z: entity.z
+        };
+        if (entity.x === x && entity.y === y && entity.z === z) {
+            return { previous, entity };
+        }
+        const updated = { ...entity, x, y, z };
+        this.entities.set(id, updated);
+        if (updated.kind === EEntityKind.Player) {
+            this.playersByName.set(updated.name.trim().toLowerCase(), updated);
+        }
+        this.sortedEntitiesCache = null;
+        this.markDirty();
+        return { previous, entity: updated };
+    }
     setBlock(x, y, z, block, states = EMPTY_BLOCK_STATES) {
         const key = coordinateKey(x, y, z);
         const existing = this.blocks.get(key);
@@ -254,6 +376,10 @@ export class SimulatedDimension {
         this.markDirty();
         return previous;
     }
+    async readRaw() {
+        await this.flush();
+        return this.store.readRaw(this.info.type);
+    }
     async flush() {
         if (this.timer !== null) {
             clearTimeout(this.timer);
@@ -268,8 +394,8 @@ export class SimulatedDimension {
         }
         this.dirty = false;
         const snapshot = {
-            blocks: this.placedBlocks,
-            entities: this.placedEntities
+            blocks: this.sortedPlacedBlocks,
+            entities: this.sortedPlacedEntities
         };
         const run = this.queue.then(async () => {
             await this.store.save(this.info.type, snapshot);
@@ -295,7 +421,7 @@ export class SimulatedDimension {
         }
         this.timer = setTimeout(() => {
             this.timer = null;
-            void this.flush().catch((error) => {
+            void this.flush().catch(error => {
                 logger.error(`Failed to persist ${this.info.key}: ${toErrorMessage(error)}`);
             });
         }, this.writeDelayMs);