@hato810424/mc-resources-plugin 0.0.0-beta.11

package/packages/mc-resources-plugin/dist/core-BHoK8fPV.mjs

@@ -0,0 +1,2300 @@
+import { createRequire } from "node:module";
+import findCacheDirectory from "find-cache-directory";
+import * as z from "zod";
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
+import path, { extname, join, relative } from "node:path";
+import { format } from "node:util";
+import chalk from "chalk";
+import { existsSync as existsSync$1, mkdirSync as mkdirSync$1, readFileSync as readFileSync$1, rmSync as rmSync$1, writeFileSync as writeFileSync$1 } from "fs";
+import { dirname, join as join$1 } from "path";
+import StreamZip from "node-stream-zip";
+import { mkdir, readFile, readdir } from "fs/promises";
+import { createCanvas, loadImage } from "canvas";
+import sharp from "sharp";
+import { createHash } from "node:crypto";
+
+//#region rolldown:runtime
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+//#region src/env.ts
+const CONFIG = {
+	OUTPUT_DIR: "./mcpacks",
+	EMPTY_OUT_DIR: false,
+	INCLUDE: [
+		"**/*.ts",
+		"**/*.tsx",
+		"**/*.js",
+		"**/*.jsx"
+	],
+	EXCLUDE: [],
+	CACHE_DIR: findCacheDirectory({
+		name: "@hato810424/mc-resources-plugin",
+		create: true
+	}),
+	START_UP_RENDER_CACHE_REFRESH: false,
+	TEXTURE_SIZE: 16,
+	WIDTH: 128,
+	HEIGHT: 128,
+	ROTATION: [
+		-30,
+		45,
+		0
+	],
+	LOG_LEVEL: "info"
+};
+
+//#endregion
+//#region src/types.ts
+const PluginOptionsSchema = z.object({
+	mcVersion: z.string().regex(/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/, "有効なバージョン形式 (X.Y.Z) を入力してください"),
+	resourcePackPath: z.string(),
+	outputPath: z.string().optional(),
+	emptyOutDir: z.boolean().optional(),
+	include: z.array(z.string()).optional(),
+	exclude: z.array(z.string()).optional(),
+	cacheDir: z.string().optional(),
+	startUpRenderCacheRefresh: z.boolean().optional(),
+	logLevel: z.enum([
+		"info",
+		"debug",
+		"error"
+	]).optional()
+});
+
+//#endregion
+//#region src/filesystem.ts
+/**
+* resourcePackPath/assets/minecraft 内のすべての画像ファイルを再帰的に取得
+*/
+function getAllImages(resourcePackPath) {
+	const images = [];
+	const minecraftPath = join(resourcePackPath, "assets", "minecraft");
+	function walkDir(currentPath, basePath) {
+		try {
+			const entries = readdirSync(currentPath);
+			for (const entry of entries) {
+				const fullPath = join(currentPath, entry);
+				if (statSync(fullPath).isDirectory()) walkDir(fullPath, basePath);
+				else {
+					const ext = extname(entry).toLowerCase();
+					if ([
+						".png",
+						".jpg",
+						".jpeg",
+						".gif",
+						".webp"
+					].includes(ext)) {
+						const relativePath = relative(basePath, fullPath).replace(/\\/g, "/");
+						images.push({
+							path: `/${relativePath}`,
+							relativePath
+						});
+					}
+				}
+			}
+		} catch {}
+	}
+	walkDir(minecraftPath, minecraftPath);
+	return images;
+}
+/**
+* 出力ディレクトリを初期化
+*/
+function initializeOutputDirectory(outputPath, emptyOutDir) {
+	if (emptyOutDir && existsSync(outputPath)) {
+		rmSync(outputPath, { recursive: true });
+		mkdirSync(outputPath, { recursive: true });
+	}
+	try {
+		mkdirSync(outputPath, { recursive: true });
+	} catch {}
+}
+/**
+* ファイルをディスクに書き込む
+*/
+function writeFiles(outputPath, jsCode, tsCode) {
+	writeFileSync(join(outputPath, "resourcepack.mjs"), jsCode, "utf-8");
+	writeFileSync(join(outputPath, "resourcepack.d.ts"), tsCode, "utf-8");
+}
+
+//#endregion
+//#region src/codeGenerator.ts
+/**
+* 画像情報から getMcResources 関数を生成
+*/
+async function generateGetResourcePackCode({ images, usedIds, itemManager, versionId, itemsUrlMap }) {
+	let filteredImages = usedIds ? images.filter((img) => {
+		const itemId = "minecraft:" + img.path.split("/").pop()?.replace(/\.[^.]+$/, "");
+		return usedIds.has(itemId);
+	}) : images;
+	const items = /* @__PURE__ */ new Set();
+	if (itemManager) {
+		(await itemManager.get3DItemsLazy(versionId)).forEach((id) => items.add(id));
+		(await itemManager.getItemIds(versionId)).forEach((id) => items.add(id));
+	}
+	let itemsImports = "";
+	const itemHashMap = /* @__PURE__ */ new Map();
+	if (itemsUrlMap) {
+		let importIndex = 0;
+		for (const [key, renderedPath] of itemsUrlMap) {
+			const lastUnderscore = key.lastIndexOf("_");
+			let itemId;
+			let optionHash;
+			if (lastUnderscore > 0) {
+				const possibleHash = key.substring(lastUnderscore + 1);
+				if (!possibleHash.includes(":")) {
+					itemId = key.substring(0, lastUnderscore);
+					optionHash = possibleHash;
+				} else {
+					itemId = key;
+					optionHash = "default";
+				}
+			} else {
+				itemId = key;
+				optionHash = "default";
+			}
+			const importVarName = `_r${importIndex}`;
+			itemsImports += `import ${importVarName} from "${renderedPath}";\n`;
+			if (!itemHashMap.has(itemId)) itemHashMap.set(itemId, /* @__PURE__ */ new Map());
+			itemHashMap.get(itemId).set(optionHash, importVarName);
+			importIndex++;
+		}
+	}
+	const mapEntries = [];
+	items.forEach((itemId) => {
+		const hashMap = itemHashMap.get(itemId);
+		if (hashMap && hashMap.has("default")) mapEntries.push(`    "${itemId}": ${hashMap.get("default")}`);
+		else mapEntries.push(`    "${itemId}": "/@hato810424:mc-resources-plugin/minecraft:${itemId.replace("minecraft:", "")}"`);
+	});
+	if (itemHashMap.size > 0) {
+		for (const [itemId, hashMap] of itemHashMap) if (!filteredImages.some((img) => `minecraft:${img.path.split("/").pop()?.replace(/\.[^.]+$/, "")}` === itemId)) for (const [optionHash, importVar] of hashMap) if (optionHash === "default") mapEntries.push(`    "${itemId}": ${importVar}`);
+		else mapEntries.push(`    "${itemId}_${optionHash}": ${importVar}`);
+	}
+	const finalMap = mapEntries.join(",\n");
+	return `${itemsImports}
+
+const resourcePack = {
+${finalMap}
+};
+
+function buildQueryString(params) {
+  return new URLSearchParams(
+    Object.entries(params).reduce((acc, [key, value]) => {
+      if (value !== undefined && value !== null) {
+        acc[key] = String(value);
+      }
+      return acc;
+    }, {})
+  ).toString();
+}
+
+function generateOptionHash(width, height, scale) {
+  const parts = [];
+  if (width !== undefined) parts.push(\`w\${width}\`);
+  if (height !== undefined) parts.push(\`h\${height}\`);
+  if (scale !== undefined) parts.push(\`s\${scale}\`);
+  return parts.join('_');
+}
+
+export function getResourcePack(itemId, options = {}) {
+  // ビルド時にレンダリングされた画像を優先的に使用
+  if (options.width || options.height || options.scale) {
+    const optionHash = generateOptionHash(options.width, options.height, options.scale);
+    const hashKey = \`\${itemId}_\${optionHash}\`;
+    const hashedUrl = resourcePack[hashKey];
+    if (hashedUrl) {
+      return hashedUrl;
+    }
+  }
+  
+  const resourceUrl = resourcePack[itemId] ?? null;
+  if (!resourceUrl) return null;
+  
+  const queryString = buildQueryString(options);
+  return queryString ? \`\${resourceUrl}?\${queryString}\` : resourceUrl;
+}
+
+export default resourcePack;`;
+}
+/**
+* TypeScript型定義を生成
+*/
+async function generateTypeDefinitions({ images, itemManager, versionId }) {
+	const filteredImages = images;
+	const FunctionOptions = `
+type FunctionOptions = {
+  width: number;
+  height?: number;
+  scale?: number;
+};
+  `.replace(/^\n/, "").replace(/[ \t]+$/, "");
+	if (itemManager && versionId) {
+		let itemMap = /* @__PURE__ */ new Set();
+		let items = /* @__PURE__ */ new Set();
+		(await itemManager.get3DItemsLazy(versionId)).forEach((id) => items.add(id));
+		(await itemManager.getItemIds(versionId)).forEach((id) => items.add(id));
+		const itemMapPromises = filteredImages.map(async (img) => {
+			const itemId = "minecraft:" + img.path.split("/").pop()?.replace(/\.[^.]+$/, "");
+			if (itemId) try {
+				if (await itemManager.getItemTexturePath(versionId, itemId)) return itemId;
+			} catch (error) {}
+			return null;
+		});
+		const results = await Promise.all(itemMapPromises);
+		for (const itemId of results) if (itemId) itemMap.add(itemId);
+		const allItems = new Set([...itemMap, ...items]);
+		const Items = itemMap;
+		const renderItems = items;
+		const hasFunctionSignature = allItems.size > 0;
+		return format(`
+      type ItemId = %s;
+      type RenderingItemId = %s;
+      %s
+      %s
+      export const resourcePack: Readonly<Record<ItemId | RenderingItemId, string>>;
+      export default resourcePack;
+      `.replace(/^\n/, "").replace(/[ \t]+$/, ""), Items.size > 0 ? Array.from(Items).map((item) => `"${item}"`).join(" | ") : "\"\"", renderItems.size > 0 ? Array.from(renderItems).map((item) => `"${item}"`).join(" | ") : "\"\"", FunctionOptions, (hasFunctionSignature ? `
+      export function getResourcePack(itemId: ItemId): string;
+      export function getResourcePack(itemId: RenderingItemId, options?: FunctionOptions): string;
+      ` : "").replace(/^\n/, "").replace(/[ \t]+$/, ""));
+	} else return format(`
+      type ItemId = %s;
+      %s
+      %s
+      export const resourcePack: Readonly<Record<ItemId, string>>;
+      export default resourcePack;
+      `.replace(/^\n/, "").replace(/[ \t]+$/, ""), filteredImages.length > 0 ? filteredImages.map((img) => `"${img.path}"`).join(" | ") : "\"\"", FunctionOptions, filteredImages.length > 0 ? "export function getResourcePack(path: ItemId): string;" : "");
+}
+
+//#endregion
+//#region package.json
+var package_default = {
+	name: "@hato810424/mc-resources-plugin",
+	type: "module",
+	scripts: {
+		"build": "tsdown",
+		"dev": "concurrently -c cyan,yellow --names esm,cjs \"tsdown --watch --format esm\" \"tsdown --watch --format cjs\"",
+		"test": "vitest",
+		"typecheck": "tsc --noEmit"
+	},
+	devDependencies: {
+		"@docusaurus/types": "^3.9.2",
+		"@types/node": "^25.0.10",
+		"concurrently": "^9.2.1",
+		"tsdown": "^0.18.4",
+		"tsx": "^4.21.0",
+		"typescript": "^5.9.3",
+		"vite": "^7.3.1",
+		"vitest": "^4.0.16",
+		"webpack": "^5.104.1",
+		"webpack-dev-server": "^5.2.3"
+	},
+	dependencies: {
+		"canvas": "^3.2.1",
+		"chalk": "^5.6.2",
+		"find-cache-directory": "^6.0.0",
+		"node-stream-zip": "^1.15.0",
+		"sharp": "^0.34.5",
+		"zod": "^4.3.6"
+	}
+};
+
+//#endregion
+//#region src/logger.ts
+const PREFIX = chalk.cyan(`[mc-resources-plugin ${package_default.version}]`) + " ";
+let logLevel = CONFIG.LOG_LEVEL;
+const logger = {
+	setLogLevel: (level) => {
+		logLevel = level === void 0 ? CONFIG.LOG_LEVEL : level;
+	},
+	info: (message) => {
+		if (logLevel === "error") return;
+		console.log(PREFIX + message);
+	},
+	warn: (message) => {
+		console.warn(PREFIX + chalk.bgRed("WARN") + " " + message);
+	},
+	debug: (message) => {
+		if (logLevel === "debug") console.debug(PREFIX + chalk.bgBlue("DEBUG") + " " + message);
+	},
+	error: (message) => {
+		console.error(PREFIX + chalk.bgRed("ERROR") + " " + message);
+	}
+};
+var logger_default = logger;
+
+//#endregion
+//#region src/mojang/minecraftVersionManager.ts
+const MOJANG_PATHS = {
+	manifest: "https://launchermeta.mojang.com/mc/game/version_manifest.json",
+	versionDetails: "version_details",
+	clientJars: "version_details",
+	langFiles: "lang_files"
+};
+const CACHE_EXPIRY_MS = 1e3 * 60 * 60 * 24 * 30;
+var MinecraftVersionManager = class {
+	cacheDir;
+	assetsFetchingTasks = /* @__PURE__ */ new Map();
+	constructor(cacheDir) {
+		this.cacheDir = cacheDir;
+		this.ensureCacheDir();
+	}
+	ensureCacheDir() {
+		if (!existsSync$1(this.cacheDir)) mkdirSync$1(this.cacheDir, { recursive: true });
+		const detailsDir = join$1(this.cacheDir, MOJANG_PATHS.versionDetails);
+		if (!existsSync$1(detailsDir)) mkdirSync$1(detailsDir, { recursive: true });
+		const clientJarsDir = join$1(this.cacheDir, MOJANG_PATHS.clientJars);
+		if (!existsSync$1(clientJarsDir)) mkdirSync$1(clientJarsDir, { recursive: true });
+	}
+	getManifestCachePath() {
+		return join$1(this.cacheDir, "version_manifest.json");
+	}
+	isCacheExpired(filePath) {
+		try {
+			const stats = __require("fs").statSync(filePath);
+			return Date.now() - stats.mtimeMs > CACHE_EXPIRY_MS;
+		} catch {
+			return true;
+		}
+	}
+	async getVersionManifest(forceRefresh = false) {
+		const cachePath = this.getManifestCachePath();
+		if (!forceRefresh && existsSync$1(cachePath) && !this.isCacheExpired(cachePath)) try {
+			const cachedData = readFileSync$1(cachePath, "utf-8");
+			return JSON.parse(cachedData);
+		} catch (error) {
+			logger_default.warn(`Failed to read version manifest cache: ${error}`);
+		}
+		try {
+			logger_default.info("Fetching version manifest from Mojang...");
+			const response = await fetch(MOJANG_PATHS.manifest);
+			if (!response.ok) throw new Error(`Failed to fetch manifest: ${response.statusText}`);
+			const manifest = await response.json();
+			writeFileSync$1(cachePath, JSON.stringify(manifest, null, 2));
+			logger_default.info("Version manifest cached successfully");
+			return manifest;
+		} catch (error) {
+			logger_default.error(`Failed to fetch version manifest: ${error}`);
+			if (existsSync$1(cachePath)) try {
+				const cachedData = readFileSync$1(cachePath, "utf-8");
+				logger_default.warn("Using stale cache due to fetch failure");
+				return JSON.parse(cachedData);
+			} catch {
+				throw new Error("Failed to fetch manifest and no valid cache available");
+			}
+			throw error;
+		}
+	}
+	async getVersionDetails(versionId, forceRefresh = false) {
+		const manifest = await this.getVersionManifest();
+		if (versionId === "latest") versionId = manifest.latest.release;
+		const versionInfo = manifest.versions.find((v) => v.id === versionId);
+		if (!versionInfo) throw new Error(`Version ${versionId} not found in manifest`);
+		const cachePath = join$1(this.cacheDir, MOJANG_PATHS.versionDetails, `${versionId}.json`);
+		if (!forceRefresh && existsSync$1(cachePath) && !this.isCacheExpired(cachePath)) try {
+			const cachedData = readFileSync$1(cachePath, "utf-8");
+			return JSON.parse(cachedData);
+		} catch (error) {
+			logger_default.warn(`Failed to read version details cache: ${error}`);
+		}
+		try {
+			logger_default.info(`Fetching details for version ${versionId}...`);
+			const response = await fetch(versionInfo.url);
+			if (!response.ok) throw new Error(`Failed to fetch version details: ${response.statusText}`);
+			const details = await response.json();
+			writeFileSync$1(cachePath, JSON.stringify(details, null, 2));
+			logger_default.info(`Version details for ${versionId} cached successfully`);
+			return details;
+		} catch (error) {
+			logger_default.error(`Failed to fetch version details for ${versionId}: ${error}`);
+			if (existsSync$1(cachePath)) try {
+				const cachedData = readFileSync$1(cachePath, "utf-8");
+				logger_default.warn(`Using stale cache for ${versionId} due to fetch failure`);
+				return JSON.parse(cachedData);
+			} catch {
+				throw new Error(`Failed to fetch version details and no valid cache available for ${versionId}`);
+			}
+			throw error;
+		}
+	}
+	async getClientJar(versionId, forceRefresh = false) {
+		const versionDetails = await this.getVersionDetails(versionId);
+		const clientJarPath = join$1(this.cacheDir, MOJANG_PATHS.clientJars, `${versionDetails.id}.jar`);
+		if (!forceRefresh && existsSync$1(clientJarPath) && !this.isCacheExpired(clientJarPath)) return clientJarPath;
+		try {
+			logger_default.info(`Downloading client jar for version ${versionDetails.id}...`);
+			const clientJarUrl = versionDetails.downloads.client.url;
+			const response = await fetch(clientJarUrl);
+			if (!response.ok) throw new Error(`Failed to download client jar: ${response.statusText}`);
+			const arrayBuffer = await response.arrayBuffer();
+			writeFileSync$1(clientJarPath, Buffer.from(arrayBuffer));
+			logger_default.info(`Client jar for version ${versionDetails.id} cached successfully`);
+			return clientJarPath;
+		} catch (error) {
+			logger_default.error(`Failed to download client jar for ${versionDetails.id}: ${error}`);
+			if (existsSync$1(clientJarPath)) {
+				logger_default.warn(`Using stale cache for ${versionDetails.id} due to download failure`);
+				return clientJarPath;
+			}
+			throw error;
+		}
+	}
+	async getAssets(versionId, forceRefresh = false) {
+		const taskKey = `${versionId}:${forceRefresh}`;
+		if (this.assetsFetchingTasks.has(taskKey)) return this.assetsFetchingTasks.get(taskKey);
+		const assetsPromise = (async () => {
+			const versionDetails = await this.getVersionDetails(versionId);
+			const assetsDirPath = join$1(this.cacheDir, MOJANG_PATHS.versionDetails, versionDetails.id);
+			if (!forceRefresh && existsSync$1(assetsDirPath) && !this.isCacheExpired(assetsDirPath)) return assetsDirPath;
+			try {
+				const jarPath = await this.getClientJar(versionId, forceRefresh);
+				const zip = new StreamZip.async({ file: jarPath });
+				if (existsSync$1(assetsDirPath)) rmSync$1(assetsDirPath, { recursive: true });
+				mkdirSync$1(assetsDirPath, { recursive: true });
+				logger_default.info(`Extracting assets for version ${versionDetails.id}...`);
+				const entries = await zip.entries();
+				for (const entry of Object.values(entries)) if (entry.name.startsWith("assets/minecraft")) {
+					const destPath = join$1(assetsDirPath, entry.name);
+					if (entry.isDirectory) mkdirSync$1(destPath, { recursive: true });
+					else {
+						mkdirSync$1(dirname(destPath), { recursive: true });
+						await zip.extract(entry.name, destPath);
+					}
+				}
+				await zip.close();
+				logger_default.info(`Assets for version ${versionDetails.id} extracted successfully`);
+				return assetsDirPath;
+			} catch (error) {
+				logger_default.error(`Failed to extract assets for ${versionDetails.id}: ${error}`);
+				if (existsSync$1(assetsDirPath)) {
+					logger_default.warn(`Using stale assets cache for ${versionDetails.id} due to extraction failure`);
+					return assetsDirPath;
+				}
+				throw error;
+			}
+		})().finally(() => {
+			this.assetsFetchingTasks.delete(taskKey);
+		});
+		this.assetsFetchingTasks.set(taskKey, assetsPromise);
+		return assetsPromise;
+	}
+	async getLangFile(versionId, lang) {
+		if (lang === "en_us") return join$1(await this.getAssets(versionId), `assets/minecraft/lang/en_us.json`);
+		const langFilePath = join$1(this.cacheDir, MOJANG_PATHS.langFiles, `${versionId}_${lang}.json`);
+		if (existsSync$1(langFilePath) && !this.isCacheExpired(langFilePath)) return langFilePath;
+		try {
+			logger_default.info(`Downloading language file: ${versionId}/${lang}`);
+			const assetIndexUrl = (await this.getVersionDetails(versionId)).assetIndex.url;
+			const assetIndexResponse = await fetch(assetIndexUrl);
+			if (!assetIndexResponse.ok) throw new Error(`Failed to fetch asset index: ${assetIndexResponse.statusText}`);
+			const assetIndex = await assetIndexResponse.json();
+			const langKey = `minecraft/lang/${lang}.json`;
+			const langObject = assetIndex.objects[langKey];
+			if (!langObject) throw new Error(`Language file not found in asset index: ${langKey}`);
+			const langHash = langObject.hash;
+			const langFileUrl = `https://resources.download.minecraft.net/${langHash.substring(0, 2)}/${langHash}`;
+			const langResponse = await fetch(langFileUrl);
+			if (!langResponse.ok) throw new Error(`Failed to download language file: ${langResponse.statusText}`);
+			const langDir = join$1(this.cacheDir, "lang_files");
+			if (!existsSync$1(langDir)) mkdirSync$1(langDir, { recursive: true });
+			writeFileSync$1(langFilePath, await langResponse.text());
+			logger_default.info(`Language file cached: ${versionId}/${lang}`);
+			return langFilePath;
+		} catch (error) {
+			logger_default.error(`Failed to download language file ${lang} for ${versionId}: ${error}`);
+			throw error;
+		}
+	}
+	async getLatestRelease() {
+		return (await this.getVersionManifest()).latest.release;
+	}
+	async getLatestSnapshot() {
+		return (await this.getVersionManifest()).latest.snapshot;
+	}
+	clearCache() {
+		const cachePath = this.getManifestCachePath();
+		if (existsSync$1(cachePath)) {
+			__require("fs").unlinkSync(cachePath);
+			logger_default.info("Version manifest cache cleared");
+		}
+	}
+};
+function createVersionManager(cacheDir) {
+	return new MinecraftVersionManager(cacheDir);
+}
+
+//#endregion
+//#region src/render/paths.ts
+/**
+* Minecraft リソースパックの標準ディレクトリ構造定義
+*/
+const MINECRAFT_PATHS = {
+	assets: "assets",
+	minecraft: "assets/minecraft",
+	models: "assets/minecraft/models",
+	modelBlocks: "assets/minecraft/models/block",
+	textures: "assets/minecraft/textures",
+	textureBlocks: "assets/minecraft/textures/block",
+	textureItems: "assets/minecraft/textures/item",
+	items: "assets/minecraft/items"
+};
+const TEXTURE_EXTENSIONS = [
+	".png",
+	".jpg",
+	".jpeg"
+];
+/**
+* Minecraft パス正規化・解析のユーティリティ
+*/
+var MinecraftPathResolver = class {
+	constructor(resourcePackPath) {
+		this.resourcePackPath = resourcePackPath;
+	}
+	/**
+	* モデルパスを正規化
+	* 例: minecraft:block/cube -> block/cube
+	*     block/cube -> block/cube
+	*     /path/to/block/cube.json -> block/cube
+	*/
+	normalizeModelPath(modelPath) {
+		let normalized = modelPath.replace(/^minecraft:/, "").replace(/\.json$/, "");
+		if (!normalized.startsWith("block/") && !normalized.startsWith("item/")) normalized = `block/${normalized}`;
+		return normalized;
+	}
+	/**
+	* テクスチャ参照を正規化（相対パスのみ返す）
+	* 例: minecraft:block/stone -> block/stone.png
+	*     stone -> block/stone.png
+	*     item/apple -> item/apple.png
+	*/
+	normalizeTexturePath(texturePath) {
+		let normalized = texturePath.replace(/^minecraft:/, "").replace(/^textures\//, "");
+		if (!normalized.startsWith("block/") && !normalized.startsWith("item/")) normalized = `block/${normalized}`;
+		if (!TEXTURE_EXTENSIONS.some((ext) => normalized.endsWith(ext))) normalized += ".png";
+		return normalized;
+	}
+	/**
+	* リソースパック内の完全なモデルファイルパスを取得
+	*/
+	getModelFilePath(modelPath) {
+		const normalized = this.normalizeModelPath(modelPath);
+		return join$1(this.resourcePackPath, MINECRAFT_PATHS.models, `${normalized}.json`);
+	}
+	/**
+	* リソースパック内の完全なテクスチャファイルパスを取得
+	*/
+	getTextureFilePath(texturePath) {
+		const normalized = this.normalizeTexturePath(texturePath);
+		return join$1(this.resourcePackPath, MINECRAFT_PATHS.textures, normalized);
+	}
+	/**
+	* ブロックモデルディレクトリの完全パスを取得
+	*/
+	getBlockModelsDir() {
+		return join$1(this.resourcePackPath, MINECRAFT_PATHS.modelBlocks);
+	}
+	/**
+	* アイテム定義ディレクトリの完全パスを取得
+	*/
+	getItemsDir() {
+		return join$1(this.resourcePackPath, MINECRAFT_PATHS.items);
+	}
+	/**
+	* モデルの基本ディレクトリを取得
+	*/
+	getModelsBaseDir() {
+		return join$1(this.resourcePackPath, MINECRAFT_PATHS.models);
+	}
+	/**
+	* テクスチャの基本ディレクトリを取得
+	*/
+	getTexturesBaseDir() {
+		return join$1(this.resourcePackPath, MINECRAFT_PATHS.textures);
+	}
+};
+
+//#endregion
+//#region src/render/Renderer.ts
+/**
+* Minecraft のティントカラーマップ（ブロック別）
+* tintindex に対応するRGB値を定義
+*/
+const TINT_COLORS = {
+	grass_block: { 0: [
+		127,
+		178,
+		56
+	] },
+	grass: { 0: [
+		127,
+		178,
+		56
+	] },
+	tall_grass: { 0: [
+		127,
+		178,
+		56
+	] },
+	seagrass: { 0: [
+		127,
+		178,
+		56
+	] },
+	vine: { 0: [
+		127,
+		178,
+		56
+	] },
+	oak_leaves: { 0: [
+		127,
+		178,
+		56
+	] },
+	birch_leaves: { 0: [
+		128,
+		168,
+		63
+	] },
+	spruce_leaves: { 0: [
+		95,
+		130,
+		60
+	] },
+	jungle_leaves: { 0: [
+		97,
+		163,
+		43
+	] },
+	acacia_leaves: { 0: [
+		155,
+		178,
+		33
+	] },
+	dark_oak_leaves: { 0: [
+		103,
+		117,
+		53
+	] },
+	cocoa: { 0: [
+		128,
+		92,
+		63
+	] },
+	cactus: { 0: [
+		95,
+		160,
+		54
+	] },
+	water: { 0: [
+		63,
+		127,
+		255
+	] },
+	water_cauldron: { 0: [
+		63,
+		127,
+		255
+	] },
+	potion: { 0: [
+		127,
+		178,
+		56
+	] },
+	tipped_arrow: { 0: [
+		127,
+		178,
+		56
+	] },
+	spawn_egg: { 0: [
+		78,
+		78,
+		78
+	] }
+};
+var MinecraftBlockRenderer = class {
+	modelsCache = /* @__PURE__ */ new Map();
+	texturesCache = /* @__PURE__ */ new Map();
+	tintedTexturesCache = /* @__PURE__ */ new Map();
+	resourcePackPathResolver;
+	modelPathResolver;
+	constructor(resourcePackPath, modelPath) {
+		this.resourcePackPathResolver = new MinecraftPathResolver(resourcePackPath);
+		this.modelPathResolver = new MinecraftPathResolver(modelPath ?? resourcePackPath);
+	}
+	/**
+	* ブロック名からモデルパスを解決
+	*/
+	async resolveBlockModelPath(blockName) {
+		return `block/${blockName.replace(/^minecraft:/, "")}`;
+	}
+	/**
+	* モデルファイルを読み込んで、parent継承を解決する
+	*/
+	async loadModel(modelPath) {
+		const fullPath = this.modelPathResolver.getModelFilePath(modelPath);
+		if (modelPath === "builtin/generated" || modelPath === "builtin/entity") return {};
+		if (this.modelsCache.has(fullPath)) return this.modelsCache.get(fullPath);
+		const content = await readFile(fullPath, "utf-8");
+		const model = JSON.parse(content);
+		if (model.parent) {
+			if (model.parent === "builtin/generated" || model.parent === "builtin/entity") {
+				this.modelsCache.set(fullPath, model);
+				return model;
+			}
+			const parentModel = await this.loadModel(model.parent);
+			const merged = {
+				...parentModel,
+				...model,
+				textures: {
+					...parentModel.textures,
+					...model.textures
+				},
+				elements: model.elements || parentModel.elements
+			};
+			this.modelsCache.set(fullPath, merged);
+			return merged;
+		}
+		this.modelsCache.set(fullPath, model);
+		return model;
+	}
+	/**
+	* テクスチャ参照を解決（#texture_nameのような参照を実際のパスに変換）
+	*/
+	resolveTexture(texture, textures, visited = /* @__PURE__ */ new Set()) {
+		if (texture.startsWith("#")) {
+			const key = texture.slice(1);
+			if (visited.has(key)) return texture;
+			visited.add(key);
+			if (textures[key]) return this.resolveTexture(textures[key], textures, visited);
+		}
+		return this.resourcePackPathResolver.normalizeTexturePath(texture);
+	}
+	/**
+	* テクスチャ画像を読み込む（上下面は水平反転、壁面は反転なし）
+	*/
+	async loadTexture(texturePath, faceName) {
+		const shouldFlipX = faceName === "up" || faceName === "down";
+		const cacheKey = shouldFlipX ? `${texturePath}:flipX` : texturePath;
+		if (this.texturesCache.has(cacheKey)) return this.texturesCache.get(cacheKey);
+		const fullPath = this.resourcePackPathResolver.getTextureFilePath(texturePath);
+		try {
+			const image = await loadImage(fullPath);
+			const canvas = createCanvas(image.width, image.height);
+			const ctx = canvas.getContext("2d");
+			if (shouldFlipX) {
+				ctx.scale(-1, 1);
+				ctx.drawImage(image, -image.width, 0);
+			} else ctx.drawImage(image, 0, 0);
+			this.texturesCache.set(cacheKey, canvas);
+			return canvas;
+		} catch (error) {
+			console.warn(`Failed to load texture: ${fullPath}`);
+			const canvas = createCanvas(16, 16);
+			const ctx = canvas.getContext("2d");
+			ctx.fillStyle = "#f800f8";
+			ctx.fillRect(0, 0, 16, 16);
+			ctx.fillStyle = "#000000";
+			ctx.fillRect(0, 0, 8, 8);
+			ctx.fillRect(8, 8, 8, 8);
+			this.texturesCache.set(cacheKey, canvas);
+			return canvas;
+		}
+	}
+	/**
+	* 3D座標を2D画面座標に投影（アイソメトリック風）
+	*/
+	project(point, cosX, sinX, cosY, sinY, cosZ, sinZ, scale) {
+		let { x, y, z: z$1 } = point;
+		const x1 = x * cosY - z$1 * sinY;
+		const z1 = x * sinY + z$1 * cosY;
+		const y1 = y * cosX - z1 * sinX;
+		const z2 = y * sinX + z1 * cosX;
+		const x2 = x1 * cosZ - y1 * sinZ;
+		const y2 = x1 * sinZ + y1 * cosZ;
+		return {
+			x: x2 * scale,
+			y: y2 * scale,
+			z: z2
+		};
+	}
+	/**
+	* テクスチャ付きの四角形を描画する（4頂点パス）
+	* @param ctx Canvas 2D コンテキスト
+	* @param centerX キャンバス中心X
+	* @param centerY キャンバス中心Y
+	* @param texture ロード済みのImageオブジェクト
+	* @param vertices 投影済みの2D頂点 4個 (z含む)
+	* @param uvCoords UV座標 4個 (0-16)
+	* @param passes テクスチャ貼り付けのパス数（1 or 2）
+	*/
+	drawTexturedQuad(ctx, centerX, centerY, texture, vertices, uvCoords, passes = 1) {
+		if (vertices.length !== 4 || uvCoords.length !== 4) return;
+		ctx.save();
+		const offset = .3;
+		const quadCenterX = vertices.reduce((sum, p) => sum + p.x, 0) / 4;
+		const quadCenterY = vertices.reduce((sum, p) => sum + p.y, 0) / 4;
+		const expand = (p) => {
+			const dx = p.x - quadCenterX;
+			const dy = p.y - quadCenterY;
+			const mag = Math.sqrt(dx * dx + dy * dy);
+			return {
+				x: p.x + dx / mag * offset,
+				y: p.y + dy / mag * offset * 3
+			};
+		};
+		const expandedVertices = vertices.map(expand);
+		ctx.beginPath();
+		ctx.moveTo(centerX + expandedVertices[0].x, centerY - expandedVertices[0].y);
+		ctx.lineTo(centerX + expandedVertices[1].x, centerY - expandedVertices[1].y);
+		ctx.lineTo(centerX + expandedVertices[2].x, centerY - expandedVertices[2].y);
+		ctx.lineTo(centerX + expandedVertices[3].x, centerY - expandedVertices[3].y);
+		ctx.closePath();
+		ctx.clip();
+		const p0 = vertices[0], p1 = vertices[1], p2 = vertices[2];
+		const u0 = uvCoords[0].u, v0 = uvCoords[0].v;
+		const u1 = uvCoords[1].u, v1 = uvCoords[1].v;
+		const u2 = uvCoords[2].u, v2 = uvCoords[2].v;
+		const delta = (u1 - u0) * (v2 - v0) - (u2 - u0) * (v1 - v0);
+		if (Math.abs(delta) > 1e-4) {
+			const m11 = ((p1.x - p0.x) * (v2 - v0) - (p2.x - p0.x) * (v1 - v0)) / delta;
+			const m12 = -((p1.y - p0.y) * (v2 - v0) - (p2.y - p0.y) * (v1 - v0)) / delta;
+			const m21 = ((p2.x - p0.x) * (u1 - u0) - (p1.x - p0.x) * (u2 - u0)) / delta;
+			const m22 = -((p2.y - p0.y) * (u1 - u0) - (p1.y - p0.y) * (u2 - u0)) / delta;
+			const dx = centerX + p0.x - (m11 * u0 + m21 * v0);
+			const dy = centerY - p0.y - (m12 * u0 + m22 * v0);
+			ctx.setTransform(m11, m12, m21, m22, dx, dy);
+			ctx.drawImage(texture, 0, 0);
+			if (passes === 2) {
+				const p3 = vertices[3];
+				const u3 = uvCoords[3].u, v3 = uvCoords[3].v;
+				const delta2 = (u2 - u0) * (v3 - v0) - (u3 - u0) * (v2 - v0);
+				if (Math.abs(delta2) > 1e-4) {
+					const m11_2 = ((p2.x - p0.x) * (v3 - v0) - (p3.x - p0.x) * (v2 - v0)) / delta2;
+					const m12_2 = -((p2.y - p0.y) * (v3 - v0) - (p3.y - p0.y) * (v2 - v0)) / delta2;
+					const m21_2 = ((p3.x - p0.x) * (u2 - u0) - (p2.x - p0.x) * (u3 - u0)) / delta2;
+					const m22_2 = -((p3.y - p0.y) * (u2 - u0) - (p2.y - p0.y) * (u3 - u0)) / delta2;
+					const dx2 = centerX + p0.x - (m11_2 * u0 + m21_2 * v0);
+					const dy2 = centerY - p0.y - (m12_2 * u0 + m22_2 * v0);
+					ctx.setTransform(m11_2, m12_2, m21_2, m22_2, dx2, dy2);
+					ctx.drawImage(texture, 0, 0);
+				}
+			}
+		}
+		ctx.restore();
+	}
+	/**
+	* テクスチャにティント色を適用（透明部分は保護）
+	*/
+	async applyTint(texture, tintColor) {
+		const [r, g, b] = tintColor;
+		const tintedCanvas = createCanvas(texture.width, texture.height);
+		const tintCtx = tintedCanvas.getContext("2d");
+		tintCtx.fillStyle = `rgb(${r},${g},${b})`;
+		tintCtx.fillRect(0, 0, texture.width, texture.height);
+		tintCtx.globalCompositeOperation = "multiply";
+		tintCtx.drawImage(texture, 0, 0);
+		const finalCanvas = createCanvas(texture.width, texture.height);
+		const finalCtx = finalCanvas.getContext("2d");
+		finalCtx.drawImage(texture, 0, 0);
+		finalCtx.globalCompositeOperation = "source-in";
+		finalCtx.drawImage(tintedCanvas, 0, 0);
+		return finalCanvas;
+	}
+	/**
+	* モデル名からティントカラーを取得
+	* 未知のブロックの場合はデフォルト緑色を返す
+	*/
+	getTintColor(modelPath, tintindex) {
+		if (tintindex === void 0) return null;
+		const nameParts = modelPath.split("/");
+		const type$1 = nameParts[0];
+		const baseName = nameParts.pop()?.replace(/\.json$/, "");
+		if (!baseName) return null;
+		const colorMap = TINT_COLORS[baseName];
+		if (!colorMap) {
+			logger_default.debug(`[Tint] Unknown ${type$1} "${baseName}" with tintindex ${tintindex}, using default green tint`);
+			return [
+				127,
+				178,
+				56
+			];
+		}
+		return colorMap[tintindex] || null;
+	}
+	/**
+	* ブロックモデルをレンダリング
+	*/
+	async renderBlock(modelPath, outputPath, options) {
+		const { width, height, rotation = CONFIG.ROTATION } = options;
+		const scale = options.scale ?? Math.round((height > width ? width : height) / 25.6);
+		let resolvedModelPath = modelPath;
+		if (modelPath.startsWith("block/")) {
+			const blockName = modelPath.replace(/^block\//, "");
+			const resolvedPath = await this.resolveBlockModelPath(blockName);
+			if (resolvedPath && resolvedPath !== `block/${blockName}`) resolvedModelPath = resolvedPath;
+		}
+		const normalizedModelPath = this.modelPathResolver.normalizeModelPath(resolvedModelPath);
+		const model = await this.loadModel(normalizedModelPath);
+		if (!model.elements) throw new Error("Model has no elements to render");
+		const canvas = createCanvas(width, height);
+		const ctx = canvas.getContext("2d");
+		ctx.imageSmoothingEnabled = false;
+		ctx.clearRect(0, 0, width, height);
+		const centerX = width / 2;
+		const centerY = height / 2;
+		const [rotX, rotY, rotZ] = rotation.map((deg) => deg * Math.PI / 180);
+		const cosX = Math.cos(rotX), sinX = Math.sin(rotX);
+		const cosY = Math.cos(rotY), sinY = Math.sin(rotY);
+		const cosZ = Math.cos(rotZ), sinZ = Math.sin(rotZ);
+		const allFacesToRender = [];
+		for (const element of model.elements) for (const faceName of [
+			"down",
+			"up",
+			"north",
+			"south",
+			"west",
+			"east"
+		]) {
+			const face = element.faces[faceName];
+			if (!face) continue;
+			const from = element.from.map((v) => v - 8);
+			const to = element.to.map((v) => v - 8);
+			let vertices = [];
+			switch (faceName) {
+				case "up":
+					vertices = [
+						{
+							x: from[0],
+							y: to[1],
+							z: to[2]
+						},
+						{
+							x: to[0],
+							y: to[1],
+							z: to[2]
+						},
+						{
+							x: to[0],
+							y: to[1],
+							z: from[2]
+						},
+						{
+							x: from[0],
+							y: to[1],
+							z: from[2]
+						}
+					];
+					break;
+				case "down":
+					vertices = [
+						{
+							x: from[0],
+							y: from[1],
+							z: from[2]
+						},
+						{
+							x: to[0],
+							y: from[1],
+							z: from[2]
+						},
+						{
+							x: to[0],
+							y: from[1],
+							z: to[2]
+						},
+						{
+							x: from[0],
+							y: from[1],
+							z: to[2]
+						}
+					];
+					break;
+				case "north":
+					vertices = [
+						{
+							x: to[0],
+							y: from[1],
+							z: from[2]
+						},
+						{
+							x: from[0],
+							y: from[1],
+							z: from[2]
+						},
+						{
+							x: from[0],
+							y: to[1],
+							z: from[2]
+						},
+						{
+							x: to[0],
+							y: to[1],
+							z: from[2]
+						}
+					];
+					break;
+				case "south":
+					vertices = [
+						{
+							x: from[0],
+							y: from[1],
+							z: to[2]
+						},
+						{
+							x: to[0],
+							y: from[1],
+							z: to[2]
+						},
+						{
+							x: to[0],
+							y: to[1],
+							z: to[2]
+						},
+						{
+							x: from[0],
+							y: to[1],
+							z: to[2]
+						}
+					];
+					break;
+				case "west":
+					vertices = [
+						{
+							x: from[0],
+							y: from[1],
+							z: from[2]
+						},
+						{
+							x: from[0],
+							y: from[1],
+							z: to[2]
+						},
+						{
+							x: from[0],
+							y: to[1],
+							z: to[2]
+						},
+						{
+							x: from[0],
+							y: to[1],
+							z: from[2]
+						}
+					];
+					break;
+				case "east":
+					vertices = [
+						{
+							x: to[0],
+							y: from[1],
+							z: to[2]
+						},
+						{
+							x: to[0],
+							y: from[1],
+							z: from[2]
+						},
+						{
+							x: to[0],
+							y: to[1],
+							z: from[2]
+						},
+						{
+							x: to[0],
+							y: to[1],
+							z: to[2]
+						}
+					];
+					break;
+			}
+			const projected = vertices.map((v) => this.project(v, cosX, sinX, cosY, sinY, cosZ, sinZ, scale));
+			const v0 = projected[0], v1 = projected[1], v2 = projected[2];
+			if ((v1.x - v0.x) * (v2.y - v0.y) - (v1.y - v0.y) * (v2.x - v0.x) >= 0) continue;
+			const avgZ = projected.reduce((sum, p) => sum + p.z, 0) / 4;
+			const minZ = Math.min(...projected.map((p) => p.z));
+			allFacesToRender.push({
+				faceName,
+				face,
+				projected,
+				avgZ,
+				minZ
+			});
+		}
+		allFacesToRender.sort((a, b) => b.avgZ - a.avgZ);
+		for (const renderData of allFacesToRender) {
+			const { faceName, face, projected } = renderData;
+			const texturePath = this.resolveTexture(face.texture, model.textures || {});
+			let texture = await this.loadTexture(texturePath, faceName);
+			if (face.tintindex !== void 0) {
+				const tintColor = this.getTintColor(normalizedModelPath, face.tintindex);
+				if (tintColor) {
+					const tintCacheKey = `${texturePath}:${faceName}:${tintColor.join(",")}`;
+					if (this.tintedTexturesCache.has(tintCacheKey)) texture = this.tintedTexturesCache.get(tintCacheKey);
+					else {
+						texture = await this.applyTint(texture, tintColor);
+						this.tintedTexturesCache.set(tintCacheKey, texture);
+					}
+				}
+			}
+			ctx.save();
+			const uv = face.uv || [
+				0,
+				0,
+				16,
+				16
+			];
+			const uMin = uv[0], vMin = uv[1];
+			const uMax = uv[2], vMax = uv[3];
+			let uvCoords = [];
+			const rotateUVCoords = (coords, rotation$1) => {
+				const steps = ((rotation$1 || 0) % 360 + 360) % 360 / 90;
+				let result = [...coords];
+				for (let i = 0; i < steps; i++) result = [
+					result[3],
+					result[0],
+					result[1],
+					result[2]
+				];
+				return result;
+			};
+			switch (faceName) {
+				case "up":
+				case "down":
+					uvCoords = [
+						{
+							u: uMin,
+							v: vMax
+						},
+						{
+							u: uMax,
+							v: vMax
+						},
+						{
+							u: uMax,
+							v: vMin
+						},
+						{
+							u: uMin,
+							v: vMin
+						}
+					];
+					break;
+				default:
+					uvCoords = [
+						{
+							u: uMax,
+							v: vMax
+						},
+						{
+							u: uMin,
+							v: vMax
+						},
+						{
+							u: uMin,
+							v: vMin
+						},
+						{
+							u: uMax,
+							v: vMin
+						}
+					];
+					break;
+			}
+			uvCoords = rotateUVCoords(uvCoords, face.rotation);
+			this.drawTexturedQuad(ctx, centerX, centerY, texture, [
+				{
+					x: projected[0].x,
+					y: projected[0].y
+				},
+				{
+					x: projected[1].x,
+					y: projected[1].y
+				},
+				{
+					x: projected[2].x,
+					y: projected[2].y
+				},
+				{
+					x: projected[3].x,
+					y: projected[3].y
+				}
+			], uvCoords, 2);
+			ctx.save();
+			ctx.setTransform(1, 0, 0, 1, 0, 0);
+			ctx.beginPath();
+			ctx.moveTo(centerX + projected[0].x, centerY - projected[0].y);
+			ctx.lineTo(centerX + projected[1].x, centerY - projected[1].y);
+			ctx.lineTo(centerX + projected[2].x, centerY - projected[2].y);
+			ctx.lineTo(centerX + projected[3].x, centerY - projected[3].y);
+			ctx.closePath();
+			let shade = 1;
+			switch (faceName) {
+				case "up":
+					shade = 1;
+					break;
+				case "down":
+					shade = .5;
+					break;
+				case "north":
+				case "south":
+					shade = .4;
+					break;
+				case "west":
+				case "east":
+					shade = .7;
+					break;
+			}
+			const shadowColor = `rgba(0, 0, 0, ${1 - shade})`;
+			ctx.globalCompositeOperation = "source-atop";
+			ctx.fillStyle = shadowColor;
+			ctx.fill();
+			ctx.strokeStyle = shadowColor;
+			ctx.lineWidth = .4;
+			ctx.lineJoin = "round";
+			ctx.stroke();
+			ctx.restore();
+		}
+		const buffer = canvas.toBuffer("image/png");
+		await mkdir(dirname(outputPath), { recursive: true });
+		await sharp(buffer).png().toFile(outputPath);
+		return outputPath;
+	}
+	/**
+	* アイテムモデルをレンダリング
+	*/
+	async renderItem(modelId, outputPath, options) {
+		const { width = CONFIG.TEXTURE_SIZE, height = CONFIG.TEXTURE_SIZE, scale = CONFIG.TEXTURE_SIZE } = options ?? {};
+		await mkdir(dirname(outputPath), { recursive: true });
+		const model = await this.loadModel(modelId);
+		if (!model) throw new Error(`Item model not found: ${modelId}`);
+		const resolvedScale = scale / 16;
+		const textures = [];
+		let currentModel = model;
+		let depth = 0;
+		while (currentModel && depth < 10) {
+			if (currentModel.textures) {
+				for (const key in currentModel.textures) if (key.startsWith("layer")) textures.push({
+					layer: currentModel.textures[key].replace("minecraft:", ""),
+					tintindex: currentModel.overrides?.[0]?.predicate?.custom_model_data !== void 0 ? 0 : void 0
+				});
+			}
+			if (currentModel.parent) {
+				const parentId = currentModel.parent.replace("minecraft:", "");
+				if (parentId === "builtin/entity") currentModel = null;
+				else currentModel = await this.loadModel(parentId);
+			} else currentModel = null;
+			depth++;
+		}
+		if (textures.length === 0) throw new Error(`No textures found for item model: ${modelId}`);
+		let composedImage;
+		for (const { layer, tintindex } of textures) {
+			const texturePath = `textures/${layer}.png`;
+			let textureCanvas = await this.loadTexture(texturePath);
+			const tintColor = TINT_COLORS[modelId.replace("item/", "")]?.[tintindex ?? 0] || TINT_COLORS[modelId]?.[tintindex ?? 0];
+			if (tintColor) {
+				const tintCacheKey = `${texturePath}:item:${tintColor.join(",")}`;
+				if (this.tintedTexturesCache.has(tintCacheKey)) textureCanvas = this.tintedTexturesCache.get(tintCacheKey);
+				else {
+					textureCanvas = await this.applyTint(textureCanvas, tintColor);
+					this.tintedTexturesCache.set(tintCacheKey, textureCanvas);
+				}
+			}
+			let sharpImage = sharp(textureCanvas.toBuffer("image/png"));
+			if (resolvedScale !== 1) sharpImage = sharpImage.resize(Math.round(16 * resolvedScale), Math.round(16 * resolvedScale), { kernel: sharp.kernel.nearest });
+			const processedBuffer = await sharpImage.toBuffer();
+			if (!composedImage) composedImage = sharp(processedBuffer);
+			else composedImage = composedImage.composite([{ input: processedBuffer }]);
+		}
+		if (!composedImage) throw new Error(`Failed to compose image for item model: ${modelId}`);
+		writeFileSync$1(outputPath, await composedImage.resize(width, height, {
+			fit: "contain",
+			background: {
+				r: 0,
+				g: 0,
+				b: 0,
+				alpha: 0
+			}
+		}).toBuffer());
+		return outputPath;
+	}
+	/**
+	* modelsディレクトリ内のすべてのモデルをレンダリング
+	*/
+	async renderAllModels(outputDir, options) {
+		const files = await readdir(this.modelPathResolver.getBlockModelsDir());
+		for (const file of files) {
+			if (!file.endsWith(".json")) continue;
+			const modelPath = file.replace(".json", "");
+			const outputPath = dirname(outputDir) + "/" + modelPath.split("/").pop() + ".png";
+			console.log(`Rendering ${file}...`);
+			try {
+				await this.renderBlock(modelPath, outputPath, options);
+				console.log(`✓ Saved to ${outputPath}`);
+			} catch (error) {
+				console.error(`✗ Failed to render ${file}:`, error);
+			}
+		}
+	}
+};
+
+//#endregion
+//#region src/mojang/itemManager.ts
+var ItemManager = class {
+	resourcePackPath;
+	versionManager;
+	items3dCache = /* @__PURE__ */ new Map();
+	itemIdsCache = /* @__PURE__ */ new Map();
+	displayTypeCache = /* @__PURE__ */ new Map();
+	constructor(resourcePackPath, versionManager) {
+		this.resourcePackPath = resourcePackPath;
+		this.versionManager = versionManager;
+	}
+	/**
+	* en_us.json からアイテムID一覧を取得
+	*/
+	async getItemIds(versionId) {
+		if (this.itemIdsCache.has(versionId)) return this.itemIdsCache.get(versionId);
+		try {
+			const langData = await this.getLangFile(versionId, "en_us");
+			const itemIds = [];
+			for (const key in langData) {
+				const parts = key.split(".");
+				if (parts.length === 3) {
+					const [category, namespace, id] = parts;
+					if ([
+						"item",
+						"block",
+						"entity"
+					].includes(category) && namespace === "minecraft") {
+						const fullId = `minecraft:${id}`;
+						itemIds.push(fullId);
+					}
+				}
+			}
+			logger_default.debug(`Extracted ${itemIds.length} item IDs from ${versionId}`);
+			this.itemIdsCache.set(versionId, itemIds);
+			return itemIds;
+		} catch (error) {
+			logger_default.error(`Failed to get item IDs for ${versionId}: ${error}`);
+			throw error;
+		}
+	}
+	/**
+	* アイテムIDからテクスチャパスを取得
+	*/
+	async getItemTexturePath(versionId, itemId) {
+		const [namespace, id] = itemId.includes(":") ? itemId.split(":") : ["minecraft", itemId];
+		if (namespace !== "minecraft") throw new Error(`Invalid item ID: ${itemId}`);
+		const assetsDir = await this.versionManager.getAssets(versionId);
+		let currentModelPath = join$1(assetsDir, "assets", "minecraft", "models", "item", `${id}.json`);
+		const visited = /* @__PURE__ */ new Set();
+		while (existsSync$1(currentModelPath) && !visited.has(currentModelPath)) {
+			visited.add(currentModelPath);
+			const content = await readFile(currentModelPath, "utf8");
+			const model = JSON.parse(content);
+			if (model.textures && model.textures.layer0) {
+				let textureId = model.textures.layer0;
+				const [, texPath] = textureId.includes(":") ? textureId.split(":") : ["minecraft", textureId];
+				return join$1(this.resourcePackPath, "assets", "minecraft", "textures", `${texPath}.png`);
+			}
+			if (model.parent) {
+				const [, parentPath] = model.parent.split(":");
+				currentModelPath = join$1(assetsDir, "assets", "minecraft", "models", parentPath.startsWith("block/") ? "block" : "item", `${parentPath.replace(/^(block|item)\//, "")}.json`);
+			} else break;
+		}
+		return null;
+	}
+	/**
+	* アイテムがティントを必要とするか判定
+	*/
+	async needsTint(versionId, itemId) {
+		const [namespace, id] = itemId.includes(":") ? itemId.split(":") : ["minecraft", itemId];
+		const cleanId = id.replace(/^item\//, "").replace(/^block\//, "");
+		if (!!TINT_COLORS[cleanId]) return true;
+		const modelPath = join$1(await this.versionManager.getAssets(versionId), "assets", "minecraft", "models", "item", `${cleanId}.json`);
+		if (existsSync$1(modelPath)) try {
+			const content = await readFile(modelPath, "utf8");
+			const model = JSON.parse(content);
+			if (model.overrides && model.overrides.length > 0) return true;
+		} catch {}
+		return false;
+	}
+	/**
+	* 指定言語でアイテムの表示名を取得
+	*/
+	async getItemLabel(versionId, itemId, lang = "en_us") {
+		try {
+			const langData = await this.getLangFile(versionId, lang);
+			const labelKey = `.minecraft.${itemId.replace("minecraft:", "")}`;
+			return langData["item" + labelKey] || langData["block" + labelKey] || langData["entity" + labelKey] || itemId;
+		} catch (error) {
+			logger_default.warn(`Failed to get label for ${itemId} in ${lang}: ${error}`);
+			return itemId;
+		}
+	}
+	/**
+	* 言語ファイルを取得（en_us はアセットから、他言語はAsset Indexから）
+	*/
+	async getLangFile(versionId, lang = "en_us") {
+		try {
+			logger_default.debug(`Loading language file: ${versionId}/${lang}`);
+			const langFilePath = await this.versionManager.getLangFile(versionId, lang);
+			if (!existsSync$1(langFilePath)) throw new Error(`Language file not found: ${lang}.json`);
+			const langData = JSON.parse(readFileSync$1(langFilePath, "utf-8"));
+			logger_default.debug(`Language file loaded: ${versionId}/${lang}`);
+			return langData;
+		} catch (error) {
+			logger_default.error(`Failed to load language file ${lang} for ${versionId}: ${error}`);
+			throw error;
+		}
+	}
+	/**
+	* 複数の言語でアイテムラベルを取得
+	*/
+	async getItemLabelsByLangs(versionId, itemId, langs = ["en_us"]) {
+		const result = {};
+		for (const lang of langs) try {
+			result[lang] = await this.getItemLabel(versionId, itemId, lang);
+		} catch (error) {
+			logger_default.warn(`Failed to get label for ${itemId} in ${lang}`);
+			result[lang] = itemId;
+		}
+		return result;
+	}
+	async isItem2DModel(modelId, assetsDir) {
+		return await this.getModelDisplayType(modelId, assetsDir) === "2d";
+	}
+	/**
+	* モデルの表示タイプを判定 ('2d' または '3d')
+	*/
+	async getModelDisplayType(modelId, assetsDir) {
+		const cacheKey = `${assetsDir}:${modelId}`;
+		if (this.displayTypeCache.has(cacheKey)) return this.displayTypeCache.get(cacheKey);
+		const BASE_PATH = join$1(assetsDir, "assets", "minecraft", "models");
+		let [, rawPath] = modelId.includes(":") ? modelId.split(":") : ["minecraft", modelId];
+		let modelPath = rawPath.startsWith("item/") || rawPath.startsWith("block/") ? rawPath : `item/${rawPath}`;
+		let depth = 0;
+		let currentPath = join$1(BASE_PATH, `${modelPath}.json`);
+		const visited = /* @__PURE__ */ new Set();
+		while (existsSync$1(currentPath) && depth < 10 && !visited.has(currentPath)) {
+			visited.add(currentPath);
+			try {
+				const content = await readFile(currentPath, "utf8");
+				const parent = JSON.parse(content).parent;
+				if (!parent) {
+					this.displayTypeCache.set(cacheKey, "3d");
+					return "3d";
+				}
+				if (parent === "minecraft:item/generated" || parent === "item/generated" || parent === "minecraft:item/handheld" || parent === "item/handheld") {
+					this.displayTypeCache.set(cacheKey, "2d");
+					return "2d";
+				}
+				if (parent.startsWith("minecraft:block/") || parent.startsWith("block/")) {
+					this.displayTypeCache.set(cacheKey, "3d");
+					return "3d";
+				}
+				[, modelPath] = parent.includes(":") ? parent.split(":") : ["minecraft", parent];
+				currentPath = join$1(BASE_PATH, `${modelPath}.json`);
+				depth++;
+			} catch {
+				this.displayTypeCache.set(cacheKey, "3d");
+				return "3d";
+			}
+		}
+		this.displayTypeCache.set(cacheKey, "3d");
+		return "3d";
+	}
+	/**
+	* minecraftId からレンダーパスを取得
+	* ブロックモデルなら block/{id}、アイテムモデルなら item/{id}
+	*/
+	async getItemRenderPath(versionId, minecraftId) {
+		const assetsDir = await this.versionManager.getAssets(versionId);
+		const baseId = minecraftId.replace(/^minecraft:/, "");
+		let itemModelPath = join$1(assetsDir, "assets", "minecraft", "models", "item", `${baseId}.json`);
+		if (existsSync$1(itemModelPath)) {
+			if (await this.getModelDisplayType(`item/${baseId}`, assetsDir) === "2d") return `item/${baseId}`;
+			try {
+				const itemModelContent = await readFile(itemModelPath, "utf8");
+				const itemModelJson = JSON.parse(itemModelContent);
+				if (itemModelJson.parent && itemModelJson.parent.startsWith("block/")) return itemModelJson.parent;
+			} catch (e) {
+				logger_default.warn(`Failed to parse item model ${itemModelPath}: ${e}`);
+			}
+			return `item/${baseId}`;
+		}
+		if (existsSync$1(join$1(assetsDir, "assets", "minecraft", "models", "block", `${baseId}.json`))) return `block/${baseId}`;
+		logger_default.warn(`Could not find render path for ${minecraftId}. Defaulting to item/${baseId}.`);
+		return `item/${baseId}`;
+	}
+	/**
+	* 3Dアイテムのリストを取得
+	*/
+	async get3DItems(versionId) {
+		if (this.items3dCache.has(versionId)) return this.items3dCache.get(versionId);
+		try {
+			const itemIds = await this.getItemIds(versionId);
+			const assetsDir = await this.versionManager.getAssets(versionId);
+			const items3d = [];
+			const batchSize = 30;
+			for (let i = 0; i < itemIds.length; i += batchSize) {
+				const batchPromises = itemIds.slice(i, i + batchSize).map(async (itemId) => ({
+					itemId,
+					type: await this.getModelDisplayType(itemId, assetsDir)
+				}));
+				const batchResults = await Promise.all(batchPromises);
+				for (const result of batchResults) if (result.type === "3d") items3d.push(result.itemId);
+			}
+			logger_default.debug(`Found ${items3d.length} 3D items out of ${itemIds.length} total items`);
+			this.items3dCache.set(versionId, items3d);
+			return items3d;
+		} catch (error) {
+			logger_default.error(`Failed to get 3D items for ${versionId}: ${error}`);
+			throw error;
+		}
+	}
+	/**
+	* 3Dアイテムのリストを段階的に取得（dev用：キャッシュからの読み込みのみ）
+	* ファイルシステム操作を最小限に抑える
+	*/
+	async get3DItemsLazy(versionId) {
+		if (this.items3dCache.has(versionId)) return this.items3dCache.get(versionId);
+		return [];
+	}
+};
+function createItemManager(resourcePackPath, versionManager) {
+	return new ItemManager(resourcePackPath, versionManager);
+}
+
+//#endregion
+//#region src/render/Builder.ts
+const clone = (value) => JSON.parse(JSON.stringify(value));
+/**
+* テクスチャ参照を解決（#texture_nameのような参照を実際のパスに変換）
+*/
+function resolveTexturePath(textures = {}, ref, visited = /* @__PURE__ */ new Set()) {
+	if (!ref) return null;
+	if (visited.has(ref)) return null;
+	if (ref.startsWith("#")) {
+		const key = ref.slice(1);
+		visited.add(ref);
+		return resolveTexturePath(textures, textures[key], visited);
+	}
+	const texturePath = new MinecraftPathResolver("").normalizeTexturePath(ref);
+	return `${MINECRAFT_PATHS.minecraft}/${texturePath}`;
+}
+/**
+* モデル参照を再帰的に検索
+*/
+function findModelReference(node) {
+	if (!node || typeof node !== "object") return null;
+	if (node.type === "minecraft:model" && typeof node.model === "string") return node.model;
+	if (node.fallback) {
+		const fallbackFound = findModelReference(node.fallback);
+		if (fallbackFound) return fallbackFound;
+	}
+	if (Array.isArray(node.cases)) for (const entry of node.cases) {
+		const found = findModelReference(entry?.model ?? entry);
+		if (found) return found;
+	}
+	if (Array.isArray(node.entries)) for (const entry of node.entries) {
+		const found = findModelReference(entry?.model ?? entry);
+		if (found) return found;
+	}
+	if (Array.isArray(node)) {
+		for (const entry of node) {
+			const found = findModelReference(entry);
+			if (found) return found;
+		}
+		return null;
+	}
+	for (const value of Object.values(node)) {
+		const found = findModelReference(value);
+		if (found) return found;
+	}
+	return null;
+}
+var ResourcePackBuilder = class {
+	modelsCache = /* @__PURE__ */ new Map();
+	resolvedModelCache = /* @__PURE__ */ new Map();
+	pathResolver;
+	constructor(resourcePackPath) {
+		this.pathResolver = new MinecraftPathResolver(resourcePackPath);
+	}
+	/**
+	* リソースパック内のすべてのブロックモデルを構築
+	*/
+	async buildAllModels() {
+		const modelsDir = this.pathResolver.getBlockModelsDir();
+		if (!existsSync$1(modelsDir)) {
+			console.warn(`Models directory not found: ${modelsDir}`);
+			return [];
+		}
+		const modelFiles = (await readdir(modelsDir)).filter((f) => f.endsWith(".json"));
+		for (const file of modelFiles) {
+			const name$1 = file.slice(0, -5);
+			const filePath = join$1(modelsDir, file);
+			try {
+				const content = await readFile(filePath, "utf-8");
+				this.modelsCache.set(name$1, JSON.parse(content));
+			} catch (error) {
+				console.warn(`Failed to load model ${name$1}:`, error);
+			}
+		}
+		const resolvedModels = [];
+		for (const name$1 of this.modelsCache.keys()) {
+			const resolvedModel = this.resolveModel(name$1);
+			if (!resolvedModel) continue;
+			const elements = resolvedModel.elements || [];
+			const usedTextures = /* @__PURE__ */ new Map();
+			for (const element of elements) {
+				const faces = element.faces || {};
+				for (const [, faceDef] of Object.entries(faces)) {
+					const texturePath = resolveTexturePath(resolvedModel.textures || {}, faceDef?.texture);
+					if (texturePath && !usedTextures.has(texturePath)) usedTextures.set(texturePath, {
+						path: texturePath,
+						dataUrl: null,
+						mcmeta: null
+					});
+				}
+			}
+			resolvedModels.push({
+				name: name$1,
+				model: resolvedModel,
+				sourceModel: clone(this.modelsCache.get(name$1)),
+				usedTextures: Array.from(usedTextures.values())
+			});
+		}
+		resolvedModels.sort((a, b) => a.name.localeCompare(b.name));
+		return resolvedModels;
+	}
+	/**
+	* すべてのアイテムを構築
+	*/
+	async buildAllItems() {
+		const itemsDir = this.pathResolver.getItemsDir();
+		if (!existsSync$1(itemsDir)) {
+			console.warn(`Items directory not found: ${itemsDir}`);
+			return [];
+		}
+		const itemFiles = (await readdir(itemsDir)).filter((f) => f.endsWith(".json"));
+		const resolvedItems = [];
+		for (const file of itemFiles) {
+			const name$1 = file.slice(0, -5);
+			const filePath = join$1(itemsDir, file);
+			try {
+				const content = await readFile(filePath, "utf-8");
+				const definition = JSON.parse(content);
+				const normalized = findModelReference(definition?.model ?? definition)?.replace(/^minecraft:/, "");
+				const isBlockModel = normalized?.startsWith("block/");
+				const texturePath = `assets/minecraft/textures/item/${normalized?.startsWith("item/") ? normalized.slice(5) : name$1}.png`;
+				resolvedItems.push({
+					name: name$1,
+					definition,
+					modelReference: normalized ?? null,
+					textureInfo: {
+						texturePath: isBlockModel ? null : texturePath,
+						dataUrl: null,
+						mcmeta: null
+					}
+				});
+			} catch (error) {
+				console.warn(`Failed to load item ${name$1}:`, error);
+			}
+		}
+		resolvedItems.sort((a, b) => a.name.localeCompare(b.name));
+		return resolvedItems;
+	}
+	/**
+	* モデルとその親の継承を解決
+	*/
+	resolveModel(name$1, chain = /* @__PURE__ */ new Set()) {
+		if (this.resolvedModelCache.has(name$1)) return this.resolvedModelCache.get(name$1);
+		if (chain.has(name$1)) return null;
+		chain.add(name$1);
+		const baseModel = this.modelsCache.get(name$1);
+		if (!baseModel) return null;
+		const model = clone(baseModel);
+		if (model.parent) {
+			let parentName = model.parent.replace(/^minecraft:/, "");
+			if (parentName.startsWith("block/")) parentName = parentName.slice(6);
+			const parentModel = this.resolveModel(parentName, chain);
+			if (parentModel) {
+				model.textures = {
+					...parentModel.textures || {},
+					...model.textures || {}
+				};
+				if (!model.elements && parentModel.elements) model.elements = clone(parentModel.elements);
+			}
+		}
+		this.resolvedModelCache.set(name$1, model);
+		return model;
+	}
+	/**
+	* キャッシュをクリア
+	*/
+	clearCache() {
+		this.modelsCache.clear();
+		this.resolvedModelCache.clear();
+	}
+};
+
+//#endregion
+//#region src/render/ResourcePack.ts
+/**
+* Minecraft リソースパック統合システム
+* リソースパック解析とレンダリングの統合ファサード
+*/
+var MinecraftResourcePack = class {
+	builder;
+	renderer;
+	constructor(resourcePackPath, modelPath) {
+		this.builder = new ResourcePackBuilder(resourcePackPath);
+		this.renderer = new MinecraftBlockRenderer(resourcePackPath, modelPath);
+	}
+	/**
+	* レンダラーを取得（内部使用）
+	*/
+	getRenderer() {
+		return this.renderer;
+	}
+	/**
+	* すべてのブロックモデルを取得
+	*/
+	async getAllBlockModels() {
+		return this.builder.buildAllModels();
+	}
+	/**
+	* すべてのアイテムを取得
+	*/
+	async getAllItems() {
+		return this.builder.buildAllItems();
+	}
+	/**
+	* ブロックモデルの詳細情報を取得
+	*/
+	async getBlockModel(blockName) {
+		return (await this.builder.buildAllModels()).find((m) => m.name === blockName) || null;
+	}
+	/**
+	* 複数のブロックをレンダリング
+	*/
+	async renderBlocks(blockNames, options = {}) {
+		const { outputDir = "./renders", width = CONFIG.WIDTH, height = options.width ?? CONFIG.HEIGHT, scale, rotation = CONFIG.ROTATION, dryRun = false } = options;
+		const renderOptions = {
+			width,
+			height,
+			scale,
+			rotation
+		};
+		const result = {
+			success: [],
+			failed: []
+		};
+		const renderTasks = blockNames.map(async (blockName) => {
+			const normalizedName = blockName.replace(/^minecraft:/, "");
+			const modelPath = `block/${normalizedName}`;
+			const outputPath = join$1(outputDir, `${normalizedName}.png`);
+			try {
+				if (dryRun) {
+					console.log(`[DRY-RUN] Would render: ${normalizedName} -> ${outputPath}`);
+					return {
+						type: "success",
+						name: normalizedName
+					};
+				} else {
+					await this.renderer.renderBlock(modelPath, outputPath, renderOptions);
+					return {
+						type: "success",
+						name: normalizedName
+					};
+				}
+			} catch (error) {
+				console.error(`❌ Failed to render ${blockName}:`, error);
+				return {
+					type: "failed",
+					name: normalizedName
+				};
+			}
+		});
+		const results = await Promise.allSettled(renderTasks);
+		for (const settledResult of results) if (settledResult.status === "fulfilled") {
+			const { type: type$1, name: name$1 } = settledResult.value;
+			if (type$1 === "success") result.success.push(name$1);
+			else result.failed.push(name$1);
+		} else result.failed.push("unknown");
+		return result;
+	}
+	/**
+	* すべてのブロックモデルをレンダリング
+	*/
+	async renderAllBlocks(options = {}) {
+		const blockNames = (await this.builder.buildAllModels()).map((m) => m.name);
+		console.log(`🎨 Rendering ${blockNames.length} block models...`);
+		const result = await this.renderBlocks(blockNames, options);
+		console.log(`\n📊 Render Summary:`);
+		console.log(`   ✅ Success: ${result.success.length}`);
+		console.log(`   ❌ Failed: ${result.failed.length}`);
+		return {
+			success: result.success.length,
+			failed: result.failed.length
+		};
+	}
+	/**
+	* モデルの使用テクスチャを取得
+	*/
+	async getModelTextures(blockName) {
+		const model = await this.getBlockModel(blockName);
+		if (!model) return [];
+		return model.usedTextures.map((t) => t.path);
+	}
+	/**
+	* キャッシュをクリア
+	*/
+	clearCache() {
+		this.builder.clearCache();
+	}
+};
+function createResourcePack(resourcePackPath, modelPath) {
+	return new MinecraftResourcePack(resourcePackPath, modelPath);
+}
+
+//#endregion
+//#region src/patternMatcher.ts
+/**
+* より正確なパターンマッチング
+*/
+function matchesPattern(path$1, patterns) {
+	const pathParts = path$1.split("/");
+	return patterns.some((pattern) => {
+		const regex = /* @__PURE__ */ new RegExp("^" + pattern.replace(/\./g, "\\.").replace(/\*\*/g, ".+").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]") + "$");
+		if (!pattern.includes("/")) return pathParts.some((part) => regex.test(part));
+		return regex.test(path$1);
+	});
+}
+
+//#endregion
+//#region src/codeScanner.ts
+/**
+* ソースコードをスキャンして、使用されているMinecraft IDとレンダリングオプションを検出
+*/
+function scanSourceCode(root, options = {}) {
+	const { include = [
+		"**/*.ts",
+		"**/*.tsx",
+		"**/*.js",
+		"**/*.jsx"
+	], exclude = [], outputPath = "./mcpacks", distDir = "./dist" } = options;
+	const usedIds = /* @__PURE__ */ new Set();
+	const renderingOptions = /* @__PURE__ */ new Map();
+	const alwaysExclude = [
+		"node_modules",
+		".git",
+		"*.d.ts"
+	];
+	const normalizedOutputPath = outputPath.replace(/^\.\//, "").replace(/\/$/, "");
+	const normalizedDistDir = distDir.replace(/^\.\//, "").replace(/\/$/, "");
+	const finalExclude = [
+		...alwaysExclude,
+		normalizedOutputPath,
+		normalizedDistDir,
+		...exclude
+	];
+	const scanDir = (dir, relativeBase = "") => {
+		try {
+			const entries = readdirSync(dir);
+			for (const entry of entries) {
+				const fullPath = join(dir, entry);
+				const relativePath = relativeBase ? `${relativeBase}/${entry}` : entry;
+				const stat = statSync(fullPath);
+				if (matchesPattern(relativePath, finalExclude)) continue;
+				if (stat.isDirectory()) scanDir(fullPath, relativePath);
+				else if (stat.isFile()) {
+					if (matchesPattern(relativePath, include)) extractResourceIds(fullPath, usedIds, renderingOptions);
+				}
+			}
+		} catch {}
+	};
+	scanDir(root);
+	return {
+		usedIds,
+		renderingOptions
+	};
+}
+/**
+* オプションのハッシュキーを生成
+*/
+function generateOptionHash(width, height, scale) {
+	const parts = [];
+	if (width !== void 0) parts.push(`w${width}`);
+	if (height !== void 0) parts.push(`h${height}`);
+	if (scale !== void 0) parts.push(`s${scale}`);
+	return parts.join("_");
+}
+/**
+* ファイルからMinecraft IDを抽出
+*/
+function extractResourceIds(filePath, usedIds, renderingOptions) {
+	try {
+		const content = readFileSync(filePath, "utf-8");
+		const resourcePackRegex = /getResourcePack\s*\(\s*["']minecraft:([a-z0-9/_\-\.]+)["']\s*,\s*\{\s*([^}]*)\s*\}\s*\)/gi;
+		let match;
+		const processedItems = /* @__PURE__ */ new Set();
+		while ((match = resourcePackRegex.exec(content)) !== null) {
+			const itemId = `minecraft:${match[1]}`;
+			usedIds.add(itemId);
+			const optionsStr = match[2];
+			let width;
+			let height;
+			let scale;
+			const widthMatch = /width\s*:\s*(\d+)/.exec(optionsStr);
+			const heightMatch = /height\s*:\s*(\d+)/.exec(optionsStr);
+			const scaleMatch = /scale\s*:\s*([\d.]+)/.exec(optionsStr);
+			if (widthMatch) width = parseInt(widthMatch[1], 10);
+			if (heightMatch) height = parseInt(heightMatch[1], 10);
+			if (scaleMatch) scale = parseFloat(scaleMatch[1]);
+			if (width || height || scale) {
+				const optionHash = generateOptionHash(width, height, scale);
+				const uniqueKey = `${itemId}:${optionHash}`;
+				if (!renderingOptions.has(uniqueKey)) renderingOptions.set(uniqueKey, {
+					itemId,
+					optionHash,
+					width,
+					height,
+					scale
+				});
+			}
+			processedItems.add(itemId);
+		}
+		const resourcePackNoOptionRegex = /getResourcePack\s*\(\s*["']minecraft:([a-z0-9/_\-\.]+)["']\s*(?!\s*,\s*\{)(?=\s*\))/gi;
+		while ((match = resourcePackNoOptionRegex.exec(content)) !== null) {
+			const itemId = `minecraft:${match[1]}`;
+			usedIds.add(itemId);
+			const uniqueKey = `${itemId}:default`;
+			if (!renderingOptions.has(uniqueKey)) renderingOptions.set(uniqueKey, {
+				itemId,
+				optionHash: "default"
+			});
+			processedItems.add(itemId);
+		}
+	} catch {}
+}
+
+//#endregion
+//#region src/plugin/core.ts
+const parseConfig = (options) => {
+	const validatedOptions = PluginOptionsSchema.parse(options);
+	return {
+		mcVersion: validatedOptions.mcVersion,
+		resourcePackPath: validatedOptions.resourcePackPath,
+		outputPath: validatedOptions.outputPath ?? CONFIG.OUTPUT_DIR,
+		emptyOutDir: validatedOptions.emptyOutDir ?? CONFIG.EMPTY_OUT_DIR,
+		include: validatedOptions.include ?? CONFIG.INCLUDE,
+		exclude: validatedOptions.exclude ?? CONFIG.EXCLUDE,
+		cacheDir: validatedOptions.cacheDir ?? CONFIG.CACHE_DIR,
+		startUpRenderCacheRefresh: validatedOptions.startUpRenderCacheRefresh ?? CONFIG.START_UP_RENDER_CACHE_REFRESH,
+		logLevel: validatedOptions.logLevel ?? CONFIG.LOG_LEVEL
+	};
+};
+var McResourcesCore = class {
+	config;
+	renderingTasks = /* @__PURE__ */ new Map();
+	fileGenerationStarted = false;
+	fileGenerationPromise = null;
+	isGenerated = false;
+	resourcePack = null;
+	versionManager;
+	itemManager;
+	constructor(config) {
+		this.config = parseConfig(config);
+		if (!this.config.cacheDir) throw new Error("Cache directory is not set. Please set the cache directory in the configuration.");
+		this.versionManager = createVersionManager(this.config.cacheDir);
+		this.itemManager = createItemManager(this.config.resourcePackPath, this.versionManager);
+		logger_default.setLogLevel(this.config.logLevel);
+	}
+	/**
+	* ItemManagerを取得
+	*/
+	getItemManager() {
+		if (!this.itemManager) throw new Error("ItemManager is not initialized. Call initializeManagers() first.");
+		return this.itemManager;
+	}
+	/**
+	* VersionManagerを取得
+	*/
+	getVersionManager() {
+		if (!this.versionManager) throw new Error("VersionManager is not initialized. Call initializeManagers() first.");
+		return this.versionManager;
+	}
+	/**
+	* Dev Modeのアセット取得
+	*/
+	async getAssetsInDevMode() {
+		setTimeout(() => {
+			this.versionManager.getAssets(this.config.mcVersion).catch((err) => {
+				logger_default.warn(`Failed to pre-fetch assets: ${err}`);
+			});
+		}, 500);
+		setTimeout(() => {
+			this.itemManager.get3DItems(this.config.mcVersion).catch((err) => {
+				logger_default.warn(`Failed to preload 3D items: ${err}`);
+			});
+		}, 1e3);
+	}
+	/**
+	* Build Modeのアセット取得
+	*/
+	async getAssetsInBuildMode() {
+		try {
+			return await this.versionManager.getAssets(this.config.mcVersion);
+		} catch (err) {
+			logger_default.warn(`Failed to pre-fetch assets: ${err}`);
+			throw err;
+		}
+	}
+	/**
+	* ファイル生成関数（遅延生成対応）
+	*/
+	async generateFiles(options = {}) {
+		const { isBuild = false, usedIds = void 0, ensureItems3d = false, itemsUrlMap = void 0 } = options;
+		if (this.isGenerated) return;
+		if (this.fileGenerationPromise) return this.fileGenerationPromise;
+		this.fileGenerationPromise = (async () => {
+			let itemManager;
+			try {
+				itemManager = this.getItemManager();
+			} catch {}
+			if (ensureItems3d && !isBuild && itemManager) try {
+				await itemManager.get3DItems(this.config.mcVersion);
+			} catch (err) {
+				logger_default.warn(`Failed to fetch 3D items: ${err}`);
+			}
+			const images = getAllImages(this.config.resourcePackPath);
+			const jsCode = await generateGetResourcePackCode({
+				images,
+				usedIds,
+				itemManager,
+				versionId: this.config.mcVersion,
+				itemsUrlMap
+			});
+			const tsCode = await generateTypeDefinitions({
+				images,
+				itemManager,
+				versionId: this.config.mcVersion
+			});
+			writeFiles(this.config.outputPath, jsCode, tsCode);
+			logger_default.info(chalk.bgGreen("Generated") + " TypeScript and JavaScript files");
+			this.isGenerated = true;
+		})();
+		return this.fileGenerationPromise;
+	}
+	/**
+	* ビルド時にアイテムをレンダリング（outputPath配下に保存）
+	*/
+	async renderItemsForBuildWithEmit(detectedIds, renderingOptions) {
+		const itemUrlMap = /* @__PURE__ */ new Map();
+		if (detectedIds.size === 0) return itemUrlMap;
+		try {
+			const assetsDirPath = await this.versionManager.getAssets(this.config.mcVersion);
+			if (!this.resourcePack) this.resourcePack = createResourcePack(this.config.resourcePackPath, assetsDirPath);
+			const renderedItemsDir = join(this.config.outputPath, "rendered-items");
+			if (existsSync(renderedItemsDir)) {
+				const files = readdirSync(renderedItemsDir);
+				for (const file of files) rmSync(join(renderedItemsDir, file), {
+					recursive: true,
+					force: true
+				});
+			}
+			mkdirSync(renderedItemsDir, { recursive: true });
+			const renderTargets = [];
+			const processedItems = /* @__PURE__ */ new Set();
+			if (renderingOptions && renderingOptions.size > 0) {
+				for (const [, opt] of renderingOptions) if (detectedIds.has(opt.itemId)) {
+					renderTargets.push({
+						itemId: opt.itemId,
+						optionHash: opt.optionHash,
+						width: opt.width,
+						height: opt.height,
+						scale: opt.scale
+					});
+					processedItems.add(opt.itemId);
+				}
+			}
+			for (const itemId of detectedIds) if (!processedItems.has(itemId)) renderTargets.push({ itemId });
+			logger_default.info(`Rendering ${renderTargets.length} items for build...`);
+			const renderPromises = renderTargets.map(async (target) => {
+				try {
+					const cleanId = target.itemId.replace("minecraft:", "");
+					const fileName = target.optionHash && target.optionHash !== "default" ? `${cleanId}_${target.optionHash}.png` : `${cleanId}.png`;
+					const outputFile = join(renderedItemsDir, fileName);
+					const isItemModel = await this.itemManager.isItem2DModel(target.itemId, assetsDirPath);
+					const modelPath = isItemModel ? `item/${cleanId}` : `block/${cleanId}`;
+					const renderOptions = {
+						width: target.width ?? (isItemModel ? CONFIG.TEXTURE_SIZE : CONFIG.WIDTH),
+						height: target.height ?? target.width ?? (isItemModel ? CONFIG.TEXTURE_SIZE : CONFIG.WIDTH),
+						...target.scale !== void 0 && { scale: target.scale }
+					};
+					if (isItemModel) await this.resourcePack.getRenderer().renderItem(modelPath, outputFile, renderOptions);
+					else await this.resourcePack.getRenderer().renderBlock(modelPath, outputFile, renderOptions);
+					logger_default.info(`Rendered: ${target.itemId} with options: ${JSON.stringify(renderOptions)}`);
+					return {
+						mapKey: target.optionHash ? `${target.itemId}_${target.optionHash}` : target.itemId,
+						relativePath: `./rendered-items/${fileName}`
+					};
+				} catch (err) {
+					logger_default.warn(`Failed to render ${target.itemId} with options ${target.optionHash || "default"}: ${err}`);
+					return null;
+				}
+			});
+			const results = await Promise.all(renderPromises);
+			for (const result of results) if (result) {
+				itemUrlMap.set(result.mapKey, result.relativePath);
+				logger_default.info(`Rendered item saved: ${result.mapKey} -> ${result.relativePath}`);
+			}
+		} catch (error) {
+			logger_default.error(`Failed to render items for build: ${error}`);
+		}
+		return itemUrlMap;
+	}
+	/**
+	* Build
+	*/
+	async build(options) {
+		initializeOutputDirectory(this.config.outputPath, this.config.emptyOutDir);
+		try {
+			await this.getAssetsInBuildMode();
+		} catch (err) {
+			logger_default.warn(`Failed to get assets: ${err}`);
+		}
+		const root = process.cwd();
+		const scanResult = scanSourceCode(root, {
+			include: this.config.include,
+			exclude: this.config.exclude,
+			outputPath: this.config.outputPath,
+			distDir: path.relative(root, options.distDir)
+		});
+		const detectedIds = scanResult.usedIds;
+		const renderingOptions = scanResult.renderingOptions;
+		logger_default.debug(`Rendering options: ${JSON.stringify(Array.from(renderingOptions?.entries() ?? []))}`);
+		const itemsUrlMap = await this.renderItemsForBuildWithEmit(detectedIds, renderingOptions);
+		await this.generateFiles({
+			usedIds: detectedIds.size > 0 ? detectedIds : void 0,
+			itemsUrlMap
+		});
+	}
+	/**
+	* Dev Server Start
+	*/
+	async devServerStart() {
+		if (this.config.startUpRenderCacheRefresh) rmSync(join(this.config.cacheDir, "renders"), {
+			recursive: true,
+			force: true
+		});
+		this.fileGenerationStarted = true;
+		logger_default.debug("Starting file generation in background...");
+		this.generateFiles({ ensureItems3d: true }).catch((err) => {
+			logger_default.warn(`Failed to generate files: ${err}`);
+		});
+	}
+	/**
+	* Dev Server Middleware
+	*/
+	async devServerMiddleware(options) {
+		const { next, req, res, isBuild, isGenerated } = options;
+		const { url, headers } = req;
+		if (!isBuild && !isGenerated && !this.fileGenerationStarted) {
+			this.fileGenerationStarted = true;
+			logger_default.debug("Starting file generation in background...");
+			this.generateFiles({ ensureItems3d: true }).catch((err) => {
+				logger_default.warn(`Failed to generate files: ${err}`);
+			});
+		}
+		if (!url?.startsWith("/@hato810424:mc-resources-plugin/minecraft:")) {
+			next();
+			return;
+		}
+		try {
+			const urlObj = new URL(url, `http://${headers.host}`);
+			const minecraftId = urlObj.pathname.replace("/@hato810424:mc-resources-plugin/minecraft:", "");
+			if (!minecraftId) {
+				res.setStatus(400);
+				res.send("Invalid minecraft ID");
+				return;
+			}
+			const assetsDirPath = await this.versionManager.getAssets(this.config.mcVersion);
+			if (!this.resourcePack) this.resourcePack = createResourcePack(this.config.resourcePackPath, assetsDirPath);
+			if (!this.itemManager) this.itemManager = createItemManager(this.config.resourcePackPath, this.versionManager);
+			const isItemModel = await this.itemManager.isItem2DModel(minecraftId, assetsDirPath);
+			const baseSize = isItemModel ? CONFIG.TEXTURE_SIZE : CONFIG.WIDTH;
+			const width = parseInt(urlObj.searchParams.get("width") ?? String(baseSize), 10);
+			const height = parseInt(urlObj.searchParams.get("height") ?? String(width), 10);
+			const scaleParam = urlObj.searchParams.get("scale");
+			const scale = scaleParam ? parseFloat(scaleParam) : void 0;
+			if (isItemModel && width === 16 && height === 16 && scale === void 0) {
+				if (!await this.itemManager.needsTint(this.config.mcVersion, minecraftId)) {
+					const texturePath = await this.itemManager.getItemTexturePath(this.config.mcVersion, minecraftId);
+					if (texturePath && existsSync(texturePath)) {
+						const imageBuffer = readFileSync(texturePath);
+						res.setHeader("Content-Type", "image/png");
+						res.send(imageBuffer);
+						return;
+					}
+				}
+			}
+			const sendResponse = (imageBuffer) => {
+				res.setHeader("Content-Type", "image/png");
+				res.send(imageBuffer);
+			};
+			const cacheKey = `${minecraftId}_${width}x${height}${scale !== void 0 ? `_${scale}` : ""}.png`;
+			const hash = createHash("md5").update(this.config.resourcePackPath).digest("hex").substring(0, 10);
+			const cacheFile = join(this.config.cacheDir, "renders", hash, cacheKey);
+			logger_default.debug(`Processing request: id=${minecraftId}, width=${width}, height=${height}, scale=${scale}, cacheKey=${cacheKey}`);
+			if (existsSync(cacheFile)) {
+				sendResponse(readFileSync(cacheFile));
+				logger_default.info(`File cache hit: ${minecraftId}`);
+				return;
+			}
+			if (this.renderingTasks.has(cacheKey)) {
+				sendResponse(await this.renderingTasks.get(cacheKey));
+				return;
+			}
+			const renderPromise = (async () => {
+				logger_default.info(`Rendering ${minecraftId}...`);
+				if (this.fileGenerationPromise) await this.fileGenerationPromise;
+				const renderPath = await this.itemManager.getItemRenderPath(this.config.mcVersion, minecraftId);
+				const renderOptions = {
+					width,
+					height
+				};
+				if (scale !== void 0) renderOptions.scale = scale;
+				let outputPath = cacheFile;
+				if (isItemModel) outputPath = await this.resourcePack.getRenderer().renderItem(renderPath, cacheFile, renderOptions);
+				else outputPath = await this.resourcePack.getRenderer().renderBlock(renderPath, cacheFile, renderOptions);
+				const imageBuffer = readFileSync(outputPath);
+				logger_default.info(`Rendered: ${minecraftId} with options: ${JSON.stringify(renderOptions)}`);
+				return imageBuffer;
+			})();
+			this.renderingTasks.set(cacheKey, renderPromise);
+			try {
+				sendResponse(await renderPromise);
+			} finally {
+				this.renderingTasks.delete(cacheKey);
+			}
+		} catch (error) {
+			logger_default.error(`Failed to render minecraft item: ${error}`);
+			const urlObj = new URL(url, `http://${headers.host}`);
+			const extractedId = urlObj.pathname.replace("/@hato810424:mc-resources-plugin/minecraft:", "");
+			const width = parseInt(urlObj.searchParams.get("width") ?? String(CONFIG.WIDTH), 10);
+			const height = parseInt(urlObj.searchParams.get("height") ?? String(width), 10);
+			const scaleParam = urlObj.searchParams.get("scale");
+			const scale = scaleParam ? parseFloat(scaleParam) : void 0;
+			const errorCacheKey = `${extractedId}_${width}x${height}${scale !== void 0 ? `_${scale}` : ""}.png`;
+			this.renderingTasks.delete(errorCacheKey);
+			res.setStatus(500);
+			res.send("Failed to render minecraft item");
+		}
+	}
+};
+
+//#endregion
+export { McResourcesCore as t };