@lzimul/minecraft-mcp 0.0.0-stage → 1.0.1

package/build/world/block-spec.js

@@ -0,0 +1,74 @@
+import { getBlockByName } from '../data/blocks.js';
+import { isSafeStateName, isSafeStateValue, normalizeStates } from './block-states.js';
+const SPEC = /^(?:([a-z0-9_.-]+):)?([a-z0-9_./-]+)(?:\[([^\]]*)\])?$/;
+const PROPERTY = /^([a-z0-9_]+)=([a-z0-9_.-]+)$/;
+const MAX_STATES = 32;
+export function parseBlockSpec(input) {
+    const spec = input.trim().toLowerCase();
+    const match = SPEC.exec(spec);
+    if (!match) {
+        return {
+            ok: false,
+            error: `Invalid block "${input}". Expected an id such as "minecraft:stone" or "minecraft:oak_stairs[facing=south]".`
+        };
+    }
+    const namespace = match[1];
+    const name = match[2];
+    const rawStates = match[3];
+    let block = getBlockByName(namespace ? `${namespace}:${name}` : name);
+    if (!block && !namespace) {
+        block = getBlockByName(`minecraft:${name}`);
+    }
+    if (!block) {
+        return {
+            ok: false,
+            error: `Unknown block "${input}". Use a block id such as "minecraft:stone"; see the resource lzimul://minecraft/blocks for the full list.`
+        };
+    }
+    const states = {};
+    if (typeof rawStates === 'string') {
+        if (rawStates.trim().length === 0) {
+            return {
+                ok: false,
+                error: `Empty block state list in "${input}". Use "minecraft:oak_stairs[facing=south]" or omit the brackets.`
+            };
+        }
+        for (const part of rawStates.split(',')) {
+            const property = PROPERTY.exec(part.trim());
+            if (!property) {
+                return {
+                    ok: false,
+                    error: `Invalid block state "${part.trim()}" in "${input}". Expected "property=value".`
+                };
+            }
+            const propertyName = property[1];
+            const propertyValue = property[2];
+            if (!isSafeStateName(propertyName)) {
+                return {
+                    ok: false,
+                    error: `Unsupported block state name "${propertyName}" in "${input}".`
+                };
+            }
+            if (!isSafeStateValue(propertyValue)) {
+                return {
+                    ok: false,
+                    error: `Unsupported block state value "${propertyValue}" for "${propertyName}" in "${input}".`
+                };
+            }
+            if (Object.hasOwn(states, propertyName)) {
+                return {
+                    ok: false,
+                    error: `Duplicate block state "${propertyName}" in "${input}".`
+                };
+            }
+            states[propertyName] = propertyValue;
+        }
+        if (Object.keys(states).length > MAX_STATES) {
+            return {
+                ok: false,
+                error: `Too many block states in "${input}" (max ${MAX_STATES}).`
+            };
+        }
+    }
+    return { ok: true, block, states: normalizeStates(states) };
+}

package/build/world/block-states.js

@@ -0,0 +1,43 @@
+export const EMPTY_BLOCK_STATES = Object.freeze({});
+const MAX_STATE_NAME_LENGTH = 64;
+const MAX_STATE_VALUE_LENGTH = 64;
+const SAFE_STATE_NAME = /^[a-z0-9_]+$/;
+const SAFE_STATE_VALUE = /^[a-z0-9_.-]+$/;
+const RESERVED_STATE_NAMES = new Set(['__proto__', 'constructor', 'prototype']);
+export function isSafeStateName(name) {
+    const normalized = name.toLowerCase();
+    return (normalized.length > 0 &&
+        normalized.length <= MAX_STATE_NAME_LENGTH &&
+        SAFE_STATE_NAME.test(normalized) &&
+        !RESERVED_STATE_NAMES.has(normalized));
+}
+export function isSafeStateValue(value) {
+    const normalized = value.toLowerCase();
+    return (normalized.length > 0 &&
+        normalized.length <= MAX_STATE_VALUE_LENGTH &&
+        SAFE_STATE_VALUE.test(normalized));
+}
+export function normalizeStates(states) {
+    if (!states) {
+        return EMPTY_BLOCK_STATES;
+    }
+    const entries = Object.entries(states)
+        .filter(([key, value]) => typeof value === 'string' &&
+        isSafeStateName(key) &&
+        isSafeStateValue(value))
+        .map(([key, value]) => [key.toLowerCase(), value.toLowerCase()])
+        .sort(([a], [b]) => a.localeCompare(b));
+    return Object.fromEntries(entries);
+}
+export function sameStates(a, b) {
+    const entries = Object.entries(a);
+    return (entries.length === Object.keys(b).length &&
+        entries.every(([key, value]) => b[key] === value));
+}
+export function formatStates(states) {
+    const entries = Object.entries(states).sort(([a], [b]) => a.localeCompare(b));
+    if (entries.length === 0) {
+        return '';
+    }
+    return `[${entries.map(([key, value]) => `${key}=${value}`).join(',')}]`;
+}

package/build/world/simulated-dimension.js

@@ -0,0 +1,129 @@
+import { WORLD_LIMITS } from '../config/world-limits.js';
+import { getBlockByName, MINECRAFT_BLOCKS } from '../data/blocks.js';
+import { toErrorMessage } from '../utils/error-message.js';
+import { EMPTY_BLOCK_STATES, normalizeStates, sameStates } from './block-states.js';
+const AIR = getBlockByName('air') ?? MINECRAFT_BLOCKS[0];
+function coordinateKey(x, y, z) {
+    return `${x},${y},${z}`;
+}
+export class SimulatedDimension {
+    info;
+    blocks = new Map();
+    store;
+    writeDelayMs;
+    timer = null;
+    queue = Promise.resolve();
+    savePromise = null;
+    dirty = false;
+    constructor(info, store, writeDelayMs = 25) {
+        this.info = info;
+        this.store = store;
+        this.writeDelayMs = writeDelayMs;
+    }
+    get modifiedBlockCount() {
+        return this.blocks.size;
+    }
+    get placedBlocks() {
+        return [...this.blocks.values()];
+    }
+    async load() {
+        const stored = await this.store.load(this.info.type);
+        let skipped = 0;
+        for (const placed of stored) {
+            const key = coordinateKey(placed.x, placed.y, placed.z);
+            const isNew = !this.blocks.has(key);
+            const outOfRange = !this.contains(placed.x, placed.y, placed.z);
+            const overLimit = isNew && this.blocks.size >= WORLD_LIMITS.maxModifiedBlocks;
+            if (outOfRange || overLimit) {
+                skipped++;
+                continue;
+            }
+            this.blocks.set(key, placed);
+        }
+        if (skipped > 0) {
+            console.error(`[lzimul-minecraft-mcp] Skipped ${skipped} invalid block(s) while loading ${this.info.key}`);
+        }
+    }
+    contains(x, y, z) {
+        return (y >= this.info.minY &&
+            y < this.info.maxY &&
+            x >= WORLD_LIMITS.minHorizontal &&
+            x <= WORLD_LIMITS.maxHorizontal &&
+            z >= WORLD_LIMITS.minHorizontal &&
+            z <= WORLD_LIMITS.maxHorizontal);
+    }
+    canSetBlock(x, y, z) {
+        return (this.blocks.has(coordinateKey(x, y, z)) ||
+            this.blocks.size < WORLD_LIMITS.maxModifiedBlocks);
+    }
+    getBlock(x, y, z) {
+        return this.blocks.get(coordinateKey(x, y, z))?.block ?? AIR;
+    }
+    getStates(x, y, z) {
+        return (this.blocks.get(coordinateKey(x, y, z))?.states ?? EMPTY_BLOCK_STATES);
+    }
+    setBlock(x, y, z, block, states = EMPTY_BLOCK_STATES) {
+        const key = coordinateKey(x, y, z);
+        const existing = this.blocks.get(key);
+        const previous = existing?.block ?? AIR;
+        const normalized = normalizeStates(states);
+        if (previous.key === block.key &&
+            sameStates(existing?.states ?? EMPTY_BLOCK_STATES, normalized)) {
+            return previous;
+        }
+        const isRemoval = block.key === AIR.key && Object.keys(normalized).length === 0;
+        if (!existing &&
+            !isRemoval &&
+            this.blocks.size >= WORLD_LIMITS.maxModifiedBlocks) {
+            throw new RangeError(`The ${this.info.displayName} world already holds the maximum of ${WORLD_LIMITS.maxModifiedBlocks} modified blocks.`);
+        }
+        if (isRemoval) {
+            this.blocks.delete(key);
+        }
+        else {
+            this.blocks.set(key, { x, y, z, block, states: normalized });
+        }
+        this.dirty = true;
+        this.scheduleFlush();
+        return previous;
+    }
+    async flush() {
+        if (this.timer !== null) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+        while (this.savePromise !== null) {
+            await this.savePromise;
+        }
+        if (!this.dirty) {
+            await this.queue;
+            return;
+        }
+        this.dirty = false;
+        const snapshot = this.placedBlocks;
+        const run = this.queue.then(async () => {
+            await this.store.save(this.info.type, snapshot);
+        });
+        this.queue = run.catch(() => {
+            this.dirty = true;
+        });
+        this.savePromise = run;
+        try {
+            await run;
+        }
+        finally {
+            this.savePromise = null;
+        }
+    }
+    scheduleFlush() {
+        if (this.timer !== null) {
+            return;
+        }
+        this.timer = setTimeout(() => {
+            this.timer = null;
+            void this.flush().catch((error) => {
+                console.error(`[lzimul-minecraft-mcp] Failed to persist ${this.info.key}: ${toErrorMessage(error)}`);
+            });
+        }, this.writeDelayMs);
+    }
+}

package/build/world/stores/file-world-store.js

@@ -0,0 +1,103 @@
+import { randomUUID } from 'node:crypto';
+import { mkdir, readFile, rename, stat, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { WORLD_LIMITS } from '../../config/world-limits.js';
+import { toErrorMessage } from '../../utils/error-message.js';
+import { fromSerialized, toSerialized } from './serialized-block.js';
+const FILE_FORMAT = 'lzimul-world/2';
+const MAX_SNAPSHOT_BYTES = 128 * 1024 * 1024;
+function warn(message) {
+    console.error(`[lzimul-minecraft-mcp] ${message}`);
+}
+export class FileWorldStore {
+    directory;
+    directoryReady = false;
+    constructor(directory) {
+        this.directory = directory;
+    }
+    async ensureDirectory() {
+        if (!this.directoryReady) {
+            await mkdir(this.directory, { recursive: true });
+            this.directoryReady = true;
+        }
+    }
+    fileFor(type) {
+        return path.join(this.directory, `${type}.json`);
+    }
+    async load(type) {
+        const file = this.fileFor(type);
+        let raw;
+        try {
+            const info = await stat(file);
+            if (info.size > MAX_SNAPSHOT_BYTES) {
+                await this.quarantine(file, `snapshot is larger than ${MAX_SNAPSHOT_BYTES} bytes`);
+                return [];
+            }
+            raw = await readFile(file, 'utf8');
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                return [];
+            }
+            throw new Error(`Cannot read world snapshot ${file}: ${toErrorMessage(error)}`, { cause: error });
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            await this.quarantine(file, 'invalid JSON');
+            return [];
+        }
+        if (!parsed || !Array.isArray(parsed.blocks)) {
+            await this.quarantine(file, 'missing blocks array');
+            return [];
+        }
+        if (parsed.blocks.length > WORLD_LIMITS.maxModifiedBlocks) {
+            await this.quarantine(file, `${parsed.blocks.length} blocks exceed the limit of ${WORLD_LIMITS.maxModifiedBlocks}`);
+            return [];
+        }
+        return parsed.blocks.flatMap(entry => {
+            const block = fromSerialized(entry);
+            if (block) {
+                return [block];
+            }
+            warn(`Skipped malformed block entry in ${file}`);
+            return [];
+        });
+    }
+    async save(type, blocks) {
+        if (blocks.length > WORLD_LIMITS.maxModifiedBlocks) {
+            throw new RangeError(`World snapshot has ${blocks.length} blocks, above the limit of ${WORLD_LIMITS.maxModifiedBlocks}`);
+        }
+        const file = this.fileFor(type);
+        try {
+            await this.ensureDirectory();
+            const sorted = blocks.toSorted((a, b) => a.x - b.x || a.y - b.y || a.z - b.z);
+            const payload = {
+                format: FILE_FORMAT,
+                dimension: `minecraft:${type}`,
+                updatedAt: new Date().toISOString(),
+                modifiedBlockCount: sorted.length,
+                blocks: sorted.map(toSerialized)
+            };
+            const temporary = `${file}.tmp`;
+            await writeFile(temporary, `${JSON.stringify(payload)}\n`, 'utf8');
+            await rename(temporary, file);
+        }
+        catch (error) {
+            this.directoryReady = false;
+            throw new Error(`Failed to write world snapshot ${file}: ${toErrorMessage(error)}`, { cause: error });
+        }
+    }
+    async quarantine(file, reason) {
+        const backup = `${file}.corrupt-${randomUUID()}`;
+        try {
+            await rename(file, backup);
+            warn(`World file ${file} is unusable (${reason}); moved it to ${backup}`);
+        }
+        catch (error) {
+            warn(`World file ${file} is unusable (${reason}); could not move it: ${toErrorMessage(error)}`);
+        }
+    }
+}

package/build/world/stores/index.js

@@ -0,0 +1,9 @@
+import { WORLD_STORAGE } from '../../config/storage.js';
+import { FileWorldStore } from './file-world-store.js';
+import { MemoryWorldStore } from './memory-world-store.js';
+export function createWorldStore() {
+    if (WORLD_STORAGE.kind === 'memory') {
+        return new MemoryWorldStore();
+    }
+    return new FileWorldStore(WORLD_STORAGE.directory);
+}

package/build/world/stores/memory-world-store.js

@@ -0,0 +1,14 @@
+import { WORLD_LIMITS } from '../../config/world-limits.js';
+export class MemoryWorldStore {
+    worlds = new Map();
+    async load(type) {
+        const stored = this.worlds.get(type);
+        return stored ? [...stored] : [];
+    }
+    async save(type, blocks) {
+        if (blocks.length > WORLD_LIMITS.maxModifiedBlocks) {
+            throw new RangeError(`World snapshot has ${blocks.length} blocks, above the limit of ${WORLD_LIMITS.maxModifiedBlocks}`);
+        }
+        this.worlds.set(type, [...blocks]);
+    }
+}

package/build/world/stores/serialized-block.js

@@ -0,0 +1,53 @@
+import { getBlockByName } from '../../data/blocks.js';
+import { normalizeStates } from '../block-states.js';
+export function toSerialized(placed) {
+    const states = normalizeStates(placed.states);
+    if (Object.keys(states).length === 0) {
+        return {
+            x: placed.x,
+            y: placed.y,
+            z: placed.z,
+            block: placed.block.key
+        };
+    }
+    return {
+        x: placed.x,
+        y: placed.y,
+        z: placed.z,
+        block: placed.block.key,
+        states
+    };
+}
+function readStates(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        return {};
+    }
+    const states = {};
+    for (const [key, propertyValue] of Object.entries(value)) {
+        if (typeof propertyValue === 'string' && propertyValue.length > 0) {
+            states[key] = propertyValue;
+        }
+    }
+    return normalizeStates(states);
+}
+export function fromSerialized(entry) {
+    if (typeof entry !== 'object' || entry === null || Array.isArray(entry)) {
+        return null;
+    }
+    const record = entry;
+    const { x, y, z, block } = record;
+    if (typeof x !== 'number' ||
+        typeof y !== 'number' ||
+        typeof z !== 'number' ||
+        !Number.isInteger(x) ||
+        !Number.isInteger(y) ||
+        !Number.isInteger(z) ||
+        typeof block !== 'string') {
+        return null;
+    }
+    const resolved = getBlockByName(block.toLowerCase());
+    if (!resolved) {
+        return null;
+    }
+    return { x, y, z, block: resolved, states: readStates(record.states) };
+}

package/build/world/world.js

@@ -0,0 +1,39 @@
+import { DIMENSIONS } from '../config/dimensions.js';
+import { toErrorMessage } from '../utils/error-message.js';
+import { SimulatedDimension } from './simulated-dimension.js';
+export class World {
+    dimensions;
+    constructor(dimensions) {
+        this.dimensions = dimensions;
+    }
+    static async load(store, writeDelayMs = 25) {
+        const entries = await Promise.all(DIMENSIONS.map(async (dimension) => {
+            const simulated = new SimulatedDimension(dimension, store, writeDelayMs);
+            try {
+                await simulated.load();
+            }
+            catch (error) {
+                throw new Error(`Failed to load the ${dimension.displayName} world: ${toErrorMessage(error)}`, { cause: error });
+            }
+            return [dimension.type, simulated];
+        }));
+        return new World(new Map(entries));
+    }
+    static listDimensions() {
+        return DIMENSIONS;
+    }
+    getDimension(type) {
+        const dimension = this.dimensions.get(type);
+        if (!dimension) {
+            throw new Error(`Unknown dimension "${type}". Use "overworld", "the_nether" or "the_end".`);
+        }
+        return dimension;
+    }
+    async flush() {
+        const results = await Promise.allSettled([...this.dimensions.values()].map(dimension => dimension.flush()));
+        const failures = results.filter((result) => result.status === 'rejected');
+        if (failures.length > 0) {
+            throw new Error(failures.map(failure => toErrorMessage(failure.reason)).join('; '));
+        }
+    }
+}

package/lib/app/server.d.ts

@@ -0,0 +1,4 @@
+import { McpServer } from '@modelcontextprotocol/server';
+import type { World } from '../world/world.js';
+export declare function createServer(world: World): McpServer;
+//# sourceMappingURL=server.d.ts.map

package/lib/app/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/app/server.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAMzD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAE/C,wBAAgB,YAAY,CAAC,KAAK,EAAE,KAAK,GAAG,SAAS,CAKpD"}

package/lib/config/dimensions.d.ts

@@ -0,0 +1,3 @@
+import type { IDimension } from '../interfaces/dimension.interface.js';
+export declare const DIMENSIONS: readonly IDimension[];
+//# sourceMappingURL=dimensions.d.ts.map

package/lib/config/dimensions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dimensions.d.ts","sourceRoot":"","sources":["../../src/config/dimensions.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sCAAsC,CAAC;AAEvE,eAAO,MAAM,UAAU,EAAE,SAAS,UAAU,EAyB3C,CAAC"}

package/lib/config/server-info.d.ts

@@ -0,0 +1,15 @@
+import { EIconTheme } from '../enums/icon-theme.enum.js';
+export declare const SERVER_INFO: {
+    name: string;
+    title: string;
+    description: string;
+    version: string;
+    websiteUrl: string;
+    icons: {
+        src: string;
+        mimeType: string;
+        sizes: string[];
+        theme: EIconTheme;
+    }[];
+};
+//# sourceMappingURL=server-info.d.ts.map

package/lib/config/server-info.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-info.d.ts","sourceRoot":"","sources":["../../src/config/server-info.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAEzD,eAAO,MAAM,WAAW;;;;;;;;;;;;CAoBvB,CAAC"}

package/lib/config/storage.d.ts

@@ -0,0 +1,8 @@
+export type EWorldStorageKind = 'file' | 'memory';
+export interface IWorldStorageConfig {
+    readonly kind: EWorldStorageKind;
+    readonly directory: string;
+    readonly writeDelayMs: number;
+}
+export declare const WORLD_STORAGE: IWorldStorageConfig;
+//# sourceMappingURL=storage.d.ts.map

package/lib/config/storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.d.ts","sourceRoot":"","sources":["../../src/config/storage.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,iBAAiB,GAAG,MAAM,GAAG,QAAQ,CAAC;AAElD,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,IAAI,EAAE,iBAAiB,CAAC;IACjC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CAC/B;AAeD,eAAO,MAAM,aAAa,EAAE,mBAI3B,CAAC"}

package/lib/config/world-limits.d.ts

@@ -0,0 +1,8 @@
+export declare const WORLD_LIMITS: {
+    readonly minHorizontal: -30000000;
+    readonly maxHorizontal: 30000000;
+    readonly minVertical: -64;
+    readonly maxVertical: 320;
+    readonly maxModifiedBlocks: 250000;
+};
+//# sourceMappingURL=world-limits.d.ts.map

package/lib/config/world-limits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"world-limits.d.ts","sourceRoot":"","sources":["../../src/config/world-limits.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,YAAY;;;;;;CAOf,CAAC"}

package/lib/data/blocks.d.ts

@@ -0,0 +1,5 @@
+import type { IBlock } from '../interfaces/block.interface.js';
+export declare const MINECRAFT_BLOCKS: readonly IBlock[];
+export declare const MINECRAFT_BLOCK_COUNT: number;
+export declare function getBlockByName(name: string): IBlock | undefined;
+//# sourceMappingURL=blocks.d.ts.map

package/lib/data/blocks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blocks.d.ts","sourceRoot":"","sources":["../../src/data/blocks.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kCAAkC,CAAC;AAE/D,eAAO,MAAM,gBAAgB,EAAE,SAAS,MAAM,EAiniB7C,CAAC;AAEF,eAAO,MAAM,qBAAqB,QAA0B,CAAC;AAQ7D,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAE/D"}

package/lib/data/items.d.ts

@@ -0,0 +1,5 @@
+import type { IItem } from '../interfaces/item.interface.js';
+export declare const MINECRAFT_ITEMS: readonly IItem[];
+export declare const MINECRAFT_ITEM_COUNT: number;
+export declare function getItemByName(name: string): IItem | undefined;
+//# sourceMappingURL=items.d.ts.map

package/lib/data/items.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"items.d.ts","sourceRoot":"","sources":["../../src/data/items.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iCAAiC,CAAC;AAE7D,eAAO,MAAM,eAAe,EAAE,SAAS,KAAK,EAg7V3C,CAAC;AAEF,eAAO,MAAM,oBAAoB,QAAyB,CAAC;AAQ3D,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK,GAAG,SAAS,CAE7D"}

package/lib/data/version.d.ts

@@ -0,0 +1,2 @@
+export declare const MINECRAFT_DATA_VERSION = "26.1";
+//# sourceMappingURL=version.d.ts.map

package/lib/data/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../src/data/version.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,sBAAsB,SAAS,CAAC"}

package/lib/enums/bounding-box.enum.d.ts

@@ -0,0 +1,5 @@
+export declare enum EBoundingBox {
+    Empty = "empty",
+    Block = "block"
+}
+//# sourceMappingURL=bounding-box.enum.d.ts.map

package/lib/enums/bounding-box.enum.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bounding-box.enum.d.ts","sourceRoot":"","sources":["../../src/enums/bounding-box.enum.ts"],"names":[],"mappings":"AAAA,oBAAY,YAAY;IACtB,KAAK,UAAU;IACf,KAAK,UAAU;CAChB"}

package/lib/enums/dimension-type.enum.d.ts

@@ -0,0 +1,6 @@
+export declare enum EDimensionType {
+    Overworld = "overworld",
+    TheNether = "the_nether",
+    TheEnd = "the_end"
+}
+//# sourceMappingURL=dimension-type.enum.d.ts.map

package/lib/enums/dimension-type.enum.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dimension-type.enum.d.ts","sourceRoot":"","sources":["../../src/enums/dimension-type.enum.ts"],"names":[],"mappings":"AAAA,oBAAY,cAAc;IACxB,SAAS,cAAc;IACvB,SAAS,eAAe;IACxB,MAAM,YAAY;CACnB"}

package/lib/enums/icon-theme.enum.d.ts

@@ -0,0 +1,5 @@
+export declare enum EIconTheme {
+    Light = "light",
+    Dark = "dark"
+}
+//# sourceMappingURL=icon-theme.enum.d.ts.map

package/lib/enums/icon-theme.enum.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"icon-theme.enum.d.ts","sourceRoot":"","sources":["../../src/enums/icon-theme.enum.ts"],"names":[],"mappings":"AAAA,oBAAY,UAAU;IACpB,KAAK,UAAU;IACf,IAAI,SAAS;CACd"}

package/lib/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}

package/lib/interfaces/block-states.interface.d.ts

@@ -0,0 +1,2 @@
+export type BlockStates = Readonly<Record<string, string>>;
+//# sourceMappingURL=block-states.interface.d.ts.map

package/lib/interfaces/block-states.interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"block-states.interface.d.ts","sourceRoot":"","sources":["../../src/interfaces/block-states.interface.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,WAAW,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC"}

package/lib/interfaces/block.interface.d.ts

@@ -0,0 +1,14 @@
+import { EBoundingBox } from '../enums/bounding-box.enum.js';
+import type { IDataEntry } from './data-entry.interface.js';
+export interface IBlock extends IDataEntry {
+    readonly hardness: number;
+    readonly resistance: number;
+    readonly stackSize: number;
+    readonly diggable: boolean;
+    readonly material: string;
+    readonly transparent: boolean;
+    readonly emitLight: number;
+    readonly filterLight: number;
+    readonly boundingBox: EBoundingBox;
+}
+//# sourceMappingURL=block.interface.d.ts.map

package/lib/interfaces/block.interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"block.interface.d.ts","sourceRoot":"","sources":["../../src/interfaces/block.interface.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAE7D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAE5D,MAAM,WAAW,MAAO,SAAQ,UAAU;IACxC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,WAAW,EAAE,YAAY,CAAC;CACpC"}

package/lib/interfaces/data-entry.interface.d.ts

@@ -0,0 +1,7 @@
+export interface IDataEntry {
+    readonly id: number;
+    readonly key: string;
+    readonly name: string;
+    readonly displayName: string;
+}
+//# sourceMappingURL=data-entry.interface.d.ts.map

package/lib/interfaces/data-entry.interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-entry.interface.d.ts","sourceRoot":"","sources":["../../src/interfaces/data-entry.interface.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC9B"}

package/lib/interfaces/dimension.interface.d.ts

@@ -0,0 +1,10 @@
+import { EDimensionType } from '../enums/dimension-type.enum.js';
+export interface IDimension {
+    readonly key: string;
+    readonly type: EDimensionType;
+    readonly displayName: string;
+    readonly minY: number;
+    readonly maxY: number;
+    readonly hasSkylight: boolean;
+}
+//# sourceMappingURL=dimension.interface.d.ts.map