@openfairygui/cli 0.2.0 → 0.3.0-alpha.2

package/dist/cli.mjs

@@ -132,49 +132,6 @@ function inspect(doc) {
 	};
 }
 //#endregion
-//#region ../functions/src/utils.ts
-/**
-* Wraps a transform function, assigning it a name for the transform stack.
-*/
-function createTransform(name, fn) {
-	Object.defineProperty(fn, "name", { value: name });
-	return fn;
-}
-function parseTextureSetMode(value) {
-	const raw = value?.trim() ?? "";
-	if (!raw) return {
-		kind: "auto",
-		raw: ""
-	};
-	if (raw === "alone") return {
-		kind: "standalone",
-		raw,
-		sizeMode: "default"
-	};
-	if (raw === "alone_npot") return {
-		kind: "standalone",
-		raw,
-		sizeMode: "npot"
-	};
-	if (raw === "alone_mof") return {
-		kind: "standalone",
-		raw,
-		sizeMode: "multipleOf4"
-	};
-	if (/^\d+$/.test(raw)) {
-		const pageIndex = Number(raw);
-		if (pageIndex >= 0 && pageIndex <= 10) return {
-			kind: "page",
-			raw,
-			pageIndex
-		};
-	}
-	return {
-		kind: "auto",
-		raw
-	};
-}
-//#endregion
 //#region ../../node_modules/.pnpm/property-graph@4.1.0/node_modules/property-graph/dist/index.mjs
 var EventDispatcher = class {
 	_listeners = {};
@@ -864,7 +821,7 @@ var ExtensibleProperty = class extends Property {
 };
 //#endregion
 //#region ../core/src/constants.ts
-const VERSION = `v0.2.0`;
+const VERSION = `v0.3.0-alpha.2`;
 /** Binary package file magic number: "FGUI" as uint32. */
 const FGUI_MAGIC = 1179080009;
 /** Null string index in the binary string table. */
@@ -9449,6 +9406,9 @@ function isAttribute(name) {
 //#region ../../node_modules/.pnpm/fast-xml-parser@5.5.10/node_modules/fast-xml-parser/src/xmlbuilder/json2xml.js
 var json2xml_default = Builder;
 //#endregion
+//#region ../../node_modules/.pnpm/fast-xml-parser@5.5.10/node_modules/fast-xml-parser/src/fxp.js
+const XMLValidator = { validate };
+//#endregion
 //#region ../core/src/utils/xml-utils.ts
 const defaultOptions = {
 	ignoreAttributes: false,
@@ -9556,7 +9516,7 @@ function parseControllerPages(pagesStr) {
 	});
 	return pages;
 }
-function parseBool(v) {
+function parseBool$1(v) {
 	if (v === void 0 || v === null) return false;
 	if (typeof v === "boolean") return v;
 	const normalized = v.trim().toLowerCase();
@@ -16228,6 +16188,19 @@ var Document = class Document {
 	}
 };
 //#endregion
+//#region ../core/src/validation.ts
+function sortProjectDiagnostics(diagnostics) {
+	return [...diagnostics].sort((left, right) => left.path.localeCompare(right.path) || left.code.localeCompare(right.code) || left.message.localeCompare(right.message));
+}
+function createProjectValidationReport(diagnostics, complete = true) {
+	const sorted = sortProjectDiagnostics(diagnostics);
+	return {
+		status: sorted.some((diagnostic) => diagnostic.severity === "error") ? "invalid" : complete ? "valid" : "incomplete",
+		complete,
+		diagnostics: sorted
+	};
+}
+//#endregion
 //#region ../core/src/utils/resource-folder.ts
 function normalizeResourceFolderPath(value) {
 	const segments = value.replace(/\\/g, "/").split("/").filter(Boolean);
@@ -16242,6 +16215,1725 @@ function resourceFolderName(value) {
 	return normalizeResourceFolderPath(value).split("/").filter(Boolean).pop() ?? "";
 }
 //#endregion
+//#region ../core/src/uam/bridge-shared.ts
+function cloneSettings(settings) {
+	return structuredClone(settings);
+}
+function liftRelations(relations) {
+	return relations.map((relation) => ({
+		targetNodeId: relation.target,
+		type: relation.type,
+		usePercent: relation.usePercent
+	}));
+}
+function liftEdgeInsets(edgeInsets) {
+	return {
+		top: edgeInsets.top,
+		bottom: edgeInsets.bottom,
+		left: edgeInsets.left,
+		right: edgeInsets.right
+	};
+}
+function cloneListItems(items) {
+	return items.map((item) => ({
+		...item,
+		...item.propertyOverrides?.length ? { propertyOverrides: item.propertyOverrides.map((property) => ({ ...property })) } : {}
+	}));
+}
+//#endregion
+//#region ../core/src/uam/validate.ts
+function pushIssue(issues, path, message, code = "invalid_uam") {
+	issues.push({
+		severity: "error",
+		code,
+		path,
+		message
+	});
+}
+function isFiniteUamPoint(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const point = value;
+	return typeof point.x === "number" && Number.isFinite(point.x) && typeof point.y === "number" && Number.isFinite(point.y);
+}
+function isFiniteUamSize(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const size = value;
+	return typeof size.width === "number" && Number.isFinite(size.width) && typeof size.height === "number" && Number.isFinite(size.height);
+}
+function isFiniteUamEdgeInsets(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const insets = value;
+	return [
+		insets.top,
+		insets.bottom,
+		insets.left,
+		insets.right
+	].every((part) => typeof part === "number" && Number.isFinite(part));
+}
+function hasExactKeys(value, keys) {
+	const actual = Object.keys(value);
+	return actual.length === keys.length && actual.every((key) => keys.includes(key));
+}
+function isValidUamComponentPropertyOverride(value) {
+	if (!value || typeof value !== "object" || !hasExactKeys(value, [
+		"target",
+		"propertyId",
+		"value"
+	])) return false;
+	const property = value;
+	return typeof property.target === "string" && property.target.length > 0 && Number.isSafeInteger(property.propertyId) && property.propertyId >= 0 && typeof property.value === "string";
+}
+const IMAGE_RESOURCE_PROPERTY_KEYS = [
+	"textureSetMode",
+	"qualityOption",
+	"quality",
+	"smoothing",
+	"duplicatePadding",
+	"scaleOption",
+	"scale9Grid",
+	"tileGridIndice"
+];
+function isValidUamImageResourceProperties(value) {
+	if (typeof value !== "object" || value === null || !hasExactKeys(value, IMAGE_RESOURCE_PROPERTY_KEYS)) return false;
+	const properties = value;
+	if (typeof properties.textureSetMode !== "string" || typeof properties.qualityOption !== "string" || !Number.isInteger(properties.quality) || properties.quality < 0 || properties.quality > 100 || typeof properties.smoothing !== "boolean" || typeof properties.duplicatePadding !== "boolean" || ![
+		0,
+		1,
+		2
+	].includes(properties.scaleOption) || !Number.isInteger(properties.tileGridIndice) || properties.tileGridIndice < 0 || properties.tileGridIndice > 31) return false;
+	if (properties.scaleOption !== 1) return properties.scale9Grid === null;
+	if (!Array.isArray(properties.scale9Grid) || properties.scale9Grid.length !== 4 || !properties.scale9Grid.every(Number.isInteger)) return false;
+	const [x, y, width, height] = properties.scale9Grid;
+	return x >= 0 && y >= 0 && width > 0 && height > 0;
+}
+const MOVIE_CLIP_RESOURCE_PROPERTY_KEYS = [
+	"interval",
+	"repeatDelay",
+	"swing",
+	"smoothing",
+	"frames"
+];
+const MOVIE_CLIP_FRAME_KEYS = [
+	"rectX",
+	"rectY",
+	"rectWidth",
+	"rectHeight",
+	"addDelay",
+	"spriteId"
+];
+function isValidUamMovieClipResourceProperties(value) {
+	if (typeof value !== "object" || value === null || !hasExactKeys(value, MOVIE_CLIP_RESOURCE_PROPERTY_KEYS)) return false;
+	const properties = value;
+	if (!Number.isInteger(properties.interval) || properties.interval < 0 || !Number.isInteger(properties.repeatDelay) || properties.repeatDelay < 0 || typeof properties.swing !== "boolean" || typeof properties.smoothing !== "boolean" || !Array.isArray(properties.frames)) return false;
+	return properties.frames.every((frame) => typeof frame === "object" && frame !== null && hasExactKeys(frame, MOVIE_CLIP_FRAME_KEYS) && [
+		frame.rectX,
+		frame.rectY,
+		frame.rectWidth,
+		frame.rectHeight,
+		frame.addDelay
+	].every(Number.isInteger) && frame.rectWidth >= 0 && frame.rectHeight >= 0 && frame.addDelay >= 0 && typeof frame.spriteId === "string");
+}
+const TEXT_PROPERTY_KEYS = [
+	"text",
+	"font",
+	"fontSize",
+	"color",
+	"align",
+	"vAlign",
+	"leading",
+	"letterSpacing",
+	"autoSize",
+	"singleLine",
+	"autoClearText",
+	"underlaySoftness",
+	"ubbEnabled",
+	"underline",
+	"italic",
+	"bold",
+	"strikethrough",
+	"strokeColor",
+	"strokeSize",
+	"shadowColor",
+	"shadowOffset"
+];
+const PLAIN_TEXT_PROPERTY_KEYS = [
+	...TEXT_PROPERTY_KEYS,
+	"demoText",
+	"templateVarsEnabled",
+	"faceDilate"
+];
+function isTextColor(value) {
+	return typeof value === "string" && /^#[0-9a-f]{6}(?:[0-9a-f]{2})?$/i.test(value);
+}
+function isValidUamTextProperties(value, nodeKind) {
+	if (typeof value !== "object" || value === null || !hasExactKeys(value, nodeKind === "richText" ? TEXT_PROPERTY_KEYS : PLAIN_TEXT_PROPERTY_KEYS)) return false;
+	const properties = value;
+	const commonValid = [properties.text, properties.font].every((item) => typeof item === "string") && Number.isInteger(properties.fontSize) && properties.fontSize > 0 && isTextColor(properties.color) && Number.isInteger(properties.align) && properties.align >= 0 && properties.align <= 2 && Number.isInteger(properties.vAlign) && properties.vAlign >= 0 && properties.vAlign <= 2 && Number.isInteger(properties.leading) && Number.isInteger(properties.letterSpacing) && Number.isInteger(properties.autoSize) && properties.autoSize >= 0 && properties.autoSize <= 4 && [
+		properties.singleLine,
+		properties.autoClearText,
+		properties.ubbEnabled,
+		properties.underline,
+		properties.italic,
+		properties.bold,
+		properties.strikethrough
+	].every((item) => typeof item === "boolean") && typeof properties.underlaySoftness === "number" && Number.isFinite(properties.underlaySoftness) && typeof properties.strokeSize === "number" && Number.isFinite(properties.strokeSize) && properties.strokeSize >= 0 && (properties.strokeColor === null ? properties.strokeSize === 1 : isTextColor(properties.strokeColor)) && isFiniteUamPoint(properties.shadowOffset) && (properties.shadowColor === null ? properties.shadowOffset.x === 0 && properties.shadowOffset.y === 0 : isTextColor(properties.shadowColor));
+	if (!commonValid || nodeKind === "richText") return commonValid;
+	return typeof properties.demoText === "string" && typeof properties.templateVarsEnabled === "boolean" && typeof properties.faceDilate === "number" && Number.isFinite(properties.faceDilate);
+}
+function textPropertiesFromNode(node) {
+	const common = {
+		text: node.text,
+		font: node.font,
+		fontSize: node.fontSize,
+		color: node.color,
+		align: node.align,
+		vAlign: node.vAlign,
+		leading: node.leading,
+		letterSpacing: node.letterSpacing,
+		autoSize: node.autoSize,
+		singleLine: node.singleLine,
+		autoClearText: node.autoClearText,
+		underlaySoftness: node.underlaySoftness,
+		ubbEnabled: node.ubbEnabled,
+		underline: node.underline,
+		italic: node.italic,
+		bold: node.bold,
+		strikethrough: node.strikethrough,
+		strokeColor: node.strokeColor,
+		strokeSize: node.strokeSize,
+		shadowColor: node.shadowColor,
+		shadowOffset: node.shadowOffset
+	};
+	if (node.kind === "richText") return common;
+	return {
+		...common,
+		demoText: node.demoText,
+		templateVarsEnabled: node.templateVarsEnabled,
+		faceDilate: node.faceDilate
+	};
+}
+const COMPONENT_PROPERTY_KEYS = [
+	"minSize",
+	"maxSize",
+	"pivot",
+	"pivotAsAnchor",
+	"overflow",
+	"margin",
+	"clipSoftness",
+	"hitTest",
+	"mask",
+	"reversedMask",
+	"scrollType",
+	"scrollBarDisplay",
+	"scrollBarFlags",
+	"scrollBarMargin",
+	"vtScrollBarRes",
+	"hzScrollBarRes",
+	"headerRes",
+	"footerRes",
+	"bgColor",
+	"bgColorEnabled",
+	"designImageAlpha",
+	"designImageLayer",
+	"designImageOffset",
+	"idNum",
+	"initName",
+	"remark",
+	"extensionType",
+	"opaque",
+	"buttonMode",
+	"sound",
+	"soundVolumeScale",
+	"downEffect",
+	"downEffectValue",
+	"dropdown",
+	"promptText",
+	"selectionController",
+	"titleType",
+	"reverse",
+	"wholeNumbers",
+	"changeOnClick",
+	"fixedGripSize",
+	"autoClearItems",
+	"customProperties"
+];
+function isValidUamComponentProperties(value) {
+	if (typeof value !== "object" || value === null || !hasExactKeys(value, COMPONENT_PROPERTY_KEYS)) return false;
+	const properties = value;
+	const strings = [
+		properties.hitTest,
+		properties.mask,
+		properties.vtScrollBarRes,
+		properties.hzScrollBarRes,
+		properties.headerRes,
+		properties.footerRes,
+		properties.bgColor,
+		properties.initName,
+		properties.remark,
+		properties.extensionType,
+		properties.sound,
+		properties.dropdown,
+		properties.promptText,
+		properties.selectionController
+	];
+	const booleans = [
+		properties.pivotAsAnchor,
+		properties.reversedMask,
+		properties.bgColorEnabled,
+		properties.opaque,
+		properties.reverse,
+		properties.wholeNumbers,
+		properties.changeOnClick,
+		properties.fixedGripSize,
+		properties.autoClearItems
+	];
+	const numbers = [
+		properties.overflow,
+		properties.scrollType,
+		properties.scrollBarDisplay,
+		properties.scrollBarFlags,
+		properties.designImageAlpha,
+		properties.designImageLayer,
+		properties.idNum,
+		properties.buttonMode,
+		properties.soundVolumeScale,
+		properties.downEffect,
+		properties.downEffectValue,
+		properties.titleType
+	];
+	return isFiniteUamSize(properties.minSize) && isFiniteUamSize(properties.maxSize) && isFiniteUamPoint(properties.pivot) && isFiniteUamEdgeInsets(properties.margin) && isFiniteUamPoint(properties.clipSoftness) && isFiniteUamEdgeInsets(properties.scrollBarMargin) && isFiniteUamPoint(properties.designImageOffset) && strings.every((item) => typeof item === "string") && booleans.every((item) => typeof item === "boolean") && numbers.every((item) => typeof item === "number" && Number.isFinite(item)) && Array.isArray(properties.customProperties) && properties.customProperties.every((property) => property && typeof property === "object" && hasExactKeys(property, [
+		"target",
+		"propertyId",
+		"label"
+	]) && typeof property.target === "string" && (property.propertyId === 0 || property.propertyId === 1) && typeof property.label === "string");
+}
+function isNullableString(value) {
+	return value === null || typeof value === "string";
+}
+function isValidUamComponentInstanceProperties(value) {
+	if (typeof value !== "object" || value === null || !("extensionType" in value)) return false;
+	const properties = value;
+	const finite = (number) => typeof number === "number" && Number.isFinite(number);
+	switch (properties.extensionType) {
+		case "Button": return hasExactKeys(properties, [
+			"extensionType",
+			"title",
+			"selectedTitle",
+			"icon",
+			"selectedIcon",
+			"titleColor",
+			"titleFontSize",
+			"controller",
+			"page",
+			"checked",
+			"sound",
+			"soundVolumeScale"
+		]) && [
+			properties.title,
+			properties.selectedTitle,
+			properties.icon,
+			properties.selectedIcon,
+			properties.titleColor,
+			properties.controller,
+			properties.page,
+			properties.sound
+		].every((item) => typeof item === "string") && finite(properties.titleFontSize) && typeof properties.checked === "boolean" && finite(properties.soundVolumeScale);
+		case "Label": return hasExactKeys(properties, [
+			"extensionType",
+			"title",
+			"icon",
+			"titleColor",
+			"titleFontSize",
+			"promptText"
+		]) && [
+			properties.title,
+			properties.icon,
+			properties.titleColor,
+			properties.promptText
+		].every((item) => typeof item === "string") && finite(properties.titleFontSize);
+		case "ComboBox": return hasExactKeys(properties, [
+			"extensionType",
+			"title",
+			"icon",
+			"visibleItemCount",
+			"selectionController",
+			"autoClearItems",
+			"items"
+		]) && [
+			properties.title,
+			properties.icon,
+			properties.selectionController
+		].every((item) => typeof item === "string") && finite(properties.visibleItemCount) && typeof properties.autoClearItems === "boolean" && Array.isArray(properties.items) && properties.items.every((item) => item && typeof item === "object" && hasExactKeys(item, [
+			"title",
+			"value",
+			"icon"
+		]) && isNullableString(item.title) && isNullableString(item.value) && isNullableString(item.icon));
+		case "ProgressBar":
+		case "Slider": return hasExactKeys(properties, [
+			"extensionType",
+			"value",
+			"max",
+			"min"
+		]) && [
+			properties.value,
+			properties.max,
+			properties.min
+		].every(finite);
+		case "ScrollBar": return hasExactKeys(properties, ["extensionType"]);
+		default: return false;
+	}
+}
+function validateControllerAction(action, knownPageIds, knownChildIds, path, issues) {
+	for (const pageId of action.fromPageIds) if (!knownPageIds.has(pageId)) pushIssue(issues, `${path}.fromPageIds`, `Unknown controller page id "${pageId}".`);
+	for (const pageId of action.toPageIds) if (!knownPageIds.has(pageId)) pushIssue(issues, `${path}.toPageIds`, `Unknown controller page id "${pageId}".`);
+	if (action.targetNodeId && !knownChildIds.has(action.targetNodeId)) pushIssue(issues, `${path}.targetNodeId`, `Unknown target node id "${action.targetNodeId}".`);
+}
+function validateGearBinding(gear, controllerMap, path, issues) {
+	const controller = controllerMap.get(gear.controllerName);
+	if (!controller) {
+		pushIssue(issues, `${path}.controllerName`, `Unknown gear controller "${gear.controllerName}".`);
+		return;
+	}
+	const pageIds = new Set(controller.pages.map((page) => page.id));
+	if (gear.kind === "display" || gear.kind === "display2") {
+		const seen = /* @__PURE__ */ new Set();
+		for (const pageId of gear.visibleOnPageIds) {
+			if (seen.has(pageId)) pushIssue(issues, `${path}.visibleOnPageIds`, `Duplicate gear page id "${pageId}".`);
+			seen.add(pageId);
+		}
+		return;
+	}
+	const seen = /* @__PURE__ */ new Set();
+	for (const state of gear.states) {
+		if (!pageIds.has(state.pageId)) pushIssue(issues, `${path}.states`, `Unknown gear state page id "${state.pageId}".`);
+		if (seen.has(state.pageId)) pushIssue(issues, `${path}.states`, `Duplicate gear state page id "${state.pageId}".`);
+		seen.add(state.pageId);
+	}
+}
+function isSafePathSegment(value) {
+	return value.length > 0 && value.trim() === value && value !== "." && value !== ".." && !/[\\/:]/.test(value) && !/[. ]$/.test(value) && !/^(?:con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\..*)?$/i.test(value);
+}
+function normalizedResourceTarget(path, fileName) {
+	if (!isSafePathSegment(fileName)) return null;
+	const segments = path.replace(/\\/g, "/").split("/").filter(Boolean);
+	if (segments.some((segment) => !isSafePathSegment(segment))) return null;
+	return [...segments, fileName].join("/");
+}
+function isSafeRelativePath(value) {
+	const segments = value.replace(/\\/g, "/").split("/").filter(Boolean);
+	return segments.length > 0 && segments.every(isSafePathSegment);
+}
+function assetFileName$1(resource) {
+	return resource.fileName || (resource.kind === "image" ? "" : resource.file) || resource.name;
+}
+function validatePackageOutputTargets(pkg, pkgPath, issues) {
+	if (!isSafePathSegment(pkg.name)) pushIssue(issues, `${pkgPath}.name`, `Invalid package output name "${pkg.name}".`, "unsafe_path");
+	const outputs = /* @__PURE__ */ new Map();
+	const folderKeys = /* @__PURE__ */ new Set();
+	for (const [folderIndex, folder] of pkg.folders.entries()) {
+		const folderPath = `${pkgPath}.folders[${folderIndex}]`;
+		if (folder.branch && !isSafePathSegment(folder.branch)) pushIssue(issues, `${folderPath}.branch`, `Invalid package branch name "${folder.branch}".`);
+		const normalizedPath = normalizeResourceFolderPath(folder.path);
+		if (folder.path === "/" || folder.path !== normalizedPath || !folder.path.split("/").filter(Boolean).every(isSafePathSegment)) {
+			pushIssue(issues, `${folderPath}.path`, "Resource folder path must be canonical, non-root, and traversal-free.", "unsafe_path");
+			continue;
+		}
+		if (typeof folder.favorite !== "boolean") pushIssue(issues, `${folderPath}.favorite`, "Resource folder favorite must be boolean.");
+		if (typeof folder.atlas !== "string") pushIssue(issues, `${folderPath}.atlas`, "Resource folder atlas must be a string.");
+		const key = `${folder.branch}\0${folder.path}`.toLowerCase();
+		if (folderKeys.has(key)) pushIssue(issues, `${folderPath}.path`, `Duplicate resource folder path "${folder.path}".`, "path_collision");
+		folderKeys.add(key);
+		const parentPath = resourceFolderParentPath(folder.path);
+		if (parentPath !== "/" && !folderKeys.has(`${folder.branch}\0${parentPath}`.toLowerCase()) && !pkg.folders.some((candidate) => candidate.branch.toLowerCase() === folder.branch.toLowerCase() && candidate.path.toLowerCase() === parentPath.toLowerCase())) pushIssue(issues, `${folderPath}.path`, `Parent resource folder "${parentPath}" does not exist.`);
+		const target = folder.path.replace(/^\/+|\/+$/g, "");
+		const descriptor = folder.branch ? "package_branch.xml" : "package.xml";
+		if (target.toLowerCase() === descriptor) pushIssue(issues, `${folderPath}.path`, `Resource folder output "${target}" conflicts with the package descriptor.`, "path_collision");
+		outputs.set(`${folder.branch}\0${target}`.toLowerCase(), folderPath);
+	}
+	for (const [resourceIndex, resource] of pkg.resources.entries()) {
+		const resourcePath = `${pkgPath}.resources[${resourceIndex}]`;
+		if (resource.branch && !isSafePathSegment(resource.branch)) pushIssue(issues, `${resourcePath}.branch`, `Invalid package branch name "${resource.branch}".`);
+		const fileName = resource.kind === "component" ? `${resource.name}.xml` : assetFileName$1(resource);
+		const target = normalizedResourceTarget(resource.path, fileName);
+		if (!target) {
+			pushIssue(issues, `${resourcePath}.path`, "Resource output path must be package-relative and traversal-free.", "unsafe_path");
+			continue;
+		}
+		const descriptor = resource.branch ? "package_branch.xml" : "package.xml";
+		if (target.toLowerCase() === descriptor) pushIssue(issues, `${resourcePath}.path`, `Resource output "${target}" conflicts with the package descriptor.`, "path_collision");
+		const key = `${resource.branch}\0${target}`.toLowerCase();
+		const previous = outputs.get(key);
+		if (previous) pushIssue(issues, `${resourcePath}.path`, `Resource output "${target}" conflicts with ${previous}.`, "path_collision");
+		else outputs.set(key, resourcePath);
+		if (resource.kind !== "component" && resource.sourcePath && !isSafeRelativePath(resource.sourcePath)) pushIssue(issues, `${resourcePath}.sourcePath`, "Resource sourcePath must be package-relative and traversal-free.", "unsafe_path");
+	}
+}
+function validateDisplayNode(node, controllerMap, knownChildIds, knownGroupIds, path, issues) {
+	if (!isFiniteUamPoint(node.position)) pushIssue(issues, `${path}.position`, "Display node position must contain finite x and y numbers.");
+	if (!isFiniteUamSize(node.size) || node.size.width < 0 || node.size.height < 0) pushIssue(issues, `${path}.size`, "Display node size must contain finite non-negative width and height values.");
+	if (typeof node.locked !== "boolean") pushIssue(issues, `${path}.locked`, "Display node locked must be boolean.");
+	if (typeof node.aspect !== "boolean") pushIssue(issues, `${path}.aspect`, "Display node aspect must be boolean.");
+	for (const [key, value] of [["minSize", node.minSize], ["maxSize", node.maxSize]]) if (!isFiniteUamSize(value) || value.width < 0 || value.height < 0) pushIssue(issues, `${path}.${key}`, `Display node ${key} must contain finite non-negative width and height values.`);
+	if (isFiniteUamSize(node.minSize) && isFiniteUamSize(node.maxSize)) {
+		if (node.maxSize.width > 0 && node.maxSize.width < node.minSize.width) pushIssue(issues, `${path}.maxSize.width`, "Display node maxSize.width must be zero or at least minSize.width.");
+		if (node.maxSize.height > 0 && node.maxSize.height < node.minSize.height) pushIssue(issues, `${path}.maxSize.height`, "Display node maxSize.height must be zero or at least minSize.height.");
+	}
+	if (!isFiniteUamPoint(node.scale)) pushIssue(issues, `${path}.scale`, "Display node scale must contain finite x and y numbers.");
+	if (!isFiniteUamPoint(node.skew)) pushIssue(issues, `${path}.skew`, "Display node skew must contain finite x and y numbers.");
+	if (![
+		node.visible,
+		node.touchable,
+		node.grayed
+	].every((value) => typeof value === "boolean")) pushIssue(issues, path, "Display node visible, touchable, and grayed must be boolean.");
+	if (typeof node.alpha !== "number" || !Number.isFinite(node.alpha) || node.alpha < 0 || node.alpha > 1) pushIssue(issues, `${path}.alpha`, "Display node alpha must be a finite number between 0 and 1.");
+	if (typeof node.rotation !== "number" || !Number.isFinite(node.rotation)) pushIssue(issues, `${path}.rotation`, "Display node rotation must be finite.");
+	if (![
+		node.tooltips,
+		node.filter,
+		node.filterData,
+		node.customData
+	].every((value) => typeof value === "string")) pushIssue(issues, path, "Display node tooltips, filter, filterData, and customData must be strings.");
+	if (![
+		"normal",
+		"none",
+		"add",
+		"multiply",
+		"screen",
+		"erase"
+	].includes(node.blendMode)) pushIssue(issues, `${path}.blendMode`, `Unsupported display node blendMode "${node.blendMode}".`);
+	if (node.filter !== "" && node.filter !== "color") pushIssue(issues, `${path}.filter`, `Unsupported display node filter "${node.filter}".`);
+	else if (node.filter === "color") {
+		const values = node.filterData.split(",").map((part) => Number(part.trim()));
+		if (values.length !== 4 || values.some((value) => !Number.isFinite(value))) pushIssue(issues, `${path}.filterData`, "Color filterData must contain four finite comma-separated numbers.");
+	} else if (node.filterData !== "") pushIssue(issues, `${path}.filterData`, "filterData must be empty when filter is empty.");
+	if (node.pivot !== void 0) {
+		if (!isFiniteUamPoint(node.pivot)) pushIssue(issues, `${path}.pivot`, "Display node pivot must contain finite x and y numbers.");
+	}
+	if (node.pivotAsAnchor !== void 0) {
+		if (typeof node.pivotAsAnchor !== "boolean") pushIssue(issues, `${path}.pivotAsAnchor`, "Display node pivotAsAnchor must be boolean.");
+	}
+	if (node.kind === "component" && node.propertyOverrides !== void 0 && (!Array.isArray(node.propertyOverrides) || !node.propertyOverrides.every(isValidUamComponentPropertyOverride))) pushIssue(issues, `${path}.propertyOverrides`, "Component property overrides must contain a non-empty target, a non-negative integer propertyId, and a string value.");
+	if (node.kind === "list" || node.kind === "tree") {
+		for (const [itemIndex, item] of node.listItems.entries()) if (item.propertyOverrides !== void 0 && (!Array.isArray(item.propertyOverrides) || !item.propertyOverrides.every(isValidUamComponentPropertyOverride))) pushIssue(issues, `${path}.listItems[${itemIndex}].propertyOverrides`, "List item property overrides must contain a non-empty target, a non-negative integer propertyId, and a string value.");
+	}
+	if ((node.kind === "text" || node.kind === "richText" || node.kind === "textInput") && !isValidUamTextProperties(textPropertiesFromNode(node), node.kind)) pushIssue(issues, path, "Text properties must be a complete valid snapshot matching the display node kind.");
+	if (node.kind === "loader" || node.kind === "loader3D") {
+		if ("group" in node) pushIssue(issues, `${path}.group`, `${node.kind} display nodes must not declare a group reference.`);
+	} else if (!("group" in node) || typeof node.group !== "string") pushIssue(issues, `${path}.group`, "Display node group must be a string.");
+	else if (node.group && (node.group === node.id || !knownGroupIds.has(node.group))) pushIssue(issues, `${path}.group`, `Group reference "${node.group}" must target another group in the same component.`);
+	for (const [gearIndex, gear] of node.gears.entries()) validateGearBinding(gear, controllerMap, `${path}.gears[${gearIndex}]`, issues);
+	for (const [relationIndex, relation] of node.relations.entries()) if (relation.targetNodeId && !knownChildIds.has(relation.targetNodeId)) pushIssue(issues, `${path}.relations[${relationIndex}]`, `Unknown relation target node id "${relation.targetNodeId}".`);
+}
+function validateUamProject(project) {
+	const issues = [];
+	const packageIds = /* @__PURE__ */ new Set();
+	const packageNames = /* @__PURE__ */ new Set();
+	const declaredProjectBranches = Array.isArray(project.branches) ? project.branches : [];
+	if (!Array.isArray(project.branches)) pushIssue(issues, "branches", "Project branches must be an array.");
+	const projectBranchNames = /* @__PURE__ */ new Set();
+	for (const [branchIndex, branchName] of declaredProjectBranches.entries()) {
+		if (!isSafePathSegment(branchName)) pushIssue(issues, `branches[${branchIndex}]`, `Invalid branch name "${branchName}".`);
+		if (projectBranchNames.has(branchName)) pushIssue(issues, `branches[${branchIndex}]`, `Duplicate branch name "${branchName}".`);
+		if (branchIndex > 0 && declaredProjectBranches[branchIndex - 1].localeCompare(branchName) > 0) pushIssue(issues, `branches[${branchIndex}]`, "Project branches must use canonical lexical order.");
+		projectBranchNames.add(branchName);
+	}
+	for (const [pkgIndex, pkg] of project.packages.entries()) {
+		const pkgPath = `packages[${pkgIndex}]`;
+		if (packageIds.has(pkg.id)) pushIssue(issues, `${pkgPath}.id`, `Duplicate package id "${pkg.id}".`, "duplicate_package_id");
+		if (packageNames.has(pkg.name.toLowerCase())) pushIssue(issues, `${pkgPath}.name`, `Duplicate package name "${pkg.name}".`, "duplicate_package_name");
+		packageIds.add(pkg.id);
+		packageNames.add(pkg.name.toLowerCase());
+		validatePackageOutputTargets(pkg, pkgPath, issues);
+		const declaredBranchNames = Array.isArray(pkg.branchNames) ? pkg.branchNames : [];
+		if (!Array.isArray(pkg.branchNames)) pushIssue(issues, `${pkgPath}.branchNames`, "Package branchNames must be an array.");
+		const packageBranchNames = /* @__PURE__ */ new Set();
+		for (const [branchIndex, branchName] of declaredBranchNames.entries()) {
+			if (!branchName || !projectBranchNames.has(branchName)) pushIssue(issues, `${pkgPath}.branchNames[${branchIndex}]`, `Unknown package branch "${branchName}".`);
+			if (packageBranchNames.has(branchName)) pushIssue(issues, `${pkgPath}.branchNames[${branchIndex}]`, `Duplicate package branch "${branchName}".`);
+			packageBranchNames.add(branchName);
+		}
+		const resourceIds = /* @__PURE__ */ new Set();
+		for (const [resourceIndex, resource] of pkg.resources.entries()) {
+			const resourcePath = `${pkgPath}.resources[${resourceIndex}]`;
+			if (resourceIds.has(resource.id)) pushIssue(issues, `${resourcePath}.id`, `Duplicate resource id "${resource.id}".`, "duplicate_resource_id");
+			resourceIds.add(resource.id);
+			if (resource.branch && !packageBranchNames.has(resource.branch)) pushIssue(issues, `${resourcePath}.branch`, `Unknown package branch "${resource.branch}".`);
+			if (resource.branchItemIds.length > declaredBranchNames.length) pushIssue(issues, `${resourcePath}.branchItemIds`, "Branch item ids exceed the package branch table.");
+			if (typeof resource.favorite !== "boolean") pushIssue(issues, `${resourcePath}.favorite`, "Resource favorite must be boolean.");
+			if (resource.kind === "image" && !isValidUamImageResourceProperties(resource.image)) pushIssue(issues, `${resourcePath}.image`, "Image resource properties must be a complete valid property snapshot.");
+			if (resource.kind === "movieClip") {
+				if (!isFiniteUamSize(resource.dimensions) || resource.dimensions.width < 0 || resource.dimensions.height < 0) pushIssue(issues, `${resourcePath}.dimensions`, "MovieClip dimensions must contain finite non-negative width and height values.");
+				if (!isValidUamMovieClipResourceProperties(resource.movieClip)) pushIssue(issues, `${resourcePath}.movieClip`, "MovieClip properties must be a complete valid property snapshot.");
+			}
+			if (resource.kind !== "component") continue;
+			const component = resource.component;
+			if (!isValidUamComponentProperties(component.properties)) pushIssue(issues, `${resourcePath}.component.properties`, "Component properties must be a complete valid property snapshot.");
+			const childIds = /* @__PURE__ */ new Set();
+			const groupIds = /* @__PURE__ */ new Set();
+			for (const [childIndex, child] of component.displayList.entries()) {
+				const childPath = `${resourcePath}.component.displayList[${childIndex}]`;
+				if (childIds.has(child.id)) pushIssue(issues, `${childPath}.id`, `Duplicate child id "${child.id}".`);
+				childIds.add(child.id);
+				if (child.kind === "group") groupIds.add(child.id);
+			}
+			const controllerMap = /* @__PURE__ */ new Map();
+			for (const [controllerIndex, controller] of component.controllers.entries()) {
+				const controllerPath = `${resourcePath}.component.controllers[${controllerIndex}]`;
+				if (controllerMap.has(controller.name)) pushIssue(issues, `${controllerPath}.name`, `Duplicate controller name "${controller.name}".`);
+				controllerMap.set(controller.name, controller);
+				const pageIds = /* @__PURE__ */ new Set();
+				for (const [pageIndex, page] of controller.pages.entries()) {
+					const pagePath = `${controllerPath}.pages[${pageIndex}]`;
+					if (pageIds.has(page.id)) pushIssue(issues, `${pagePath}.id`, `Duplicate controller page id "${page.id}".`);
+					pageIds.add(page.id);
+				}
+				for (const [actionIndex, action] of controller.actions.entries()) validateControllerAction(action, pageIds, childIds, `${controllerPath}.actions[${actionIndex}]`, issues);
+			}
+			for (const [childIndex, child] of component.displayList.entries()) {
+				if (child.kind === "component" && child.instanceProperties !== void 0 && !isValidUamComponentInstanceProperties(child.instanceProperties)) pushIssue(issues, `${resourcePath}.component.displayList[${childIndex}].instanceProperties`, "Component instance properties must be a complete valid extension snapshot.");
+				validateDisplayNode(child, controllerMap, childIds, groupIds, `${resourcePath}.component.displayList[${childIndex}]`, issues);
+			}
+		}
+	}
+	return issues;
+}
+//#endregion
+//#region ../core/src/uam/reference-validation.ts
+function findUiResource(project, value) {
+	if (!value.startsWith("ui://")) return null;
+	const reference = value.slice(5);
+	const slashIndex = reference.indexOf("/");
+	if (slashIndex >= 0) {
+		const packageKey = reference.slice(0, slashIndex);
+		const resourceKey = reference.slice(slashIndex + 1);
+		return project.packages.find((candidate) => candidate.id === packageKey || candidate.name === packageKey)?.resources.find((resource) => resource.id === resourceKey || resource.name === resourceKey || resource.name.replace(/\.[^.]+$/, "") === resourceKey) ?? null;
+	}
+	const pkg = [...project.packages].sort((left, right) => right.id.length - left.id.length).find((candidate) => reference.startsWith(candidate.id));
+	return pkg?.resources.find((resource) => resource.id === reference.slice(pkg.id.length)) ?? null;
+}
+function collectUiReferences(value) {
+	if (Array.isArray(value)) return value.flatMap(collectUiReferences);
+	if (typeof value === "object" && value !== null) return Object.values(value).flatMap(collectUiReferences);
+	if (typeof value !== "string") return [];
+	return [...value.matchAll(/ui:\/\/[^\s"'<>()[\]{}]+/g)].map((match) => match[0]);
+}
+function validateUamReferences(project) {
+	const issues = [];
+	const findResource = (packageId, resourceId) => project.packages.find((pkg) => pkg.id === packageId)?.resources.find((resource) => resource.id === resourceId);
+	const pushMissing = (path, packageId, resourceId, expectedKinds, owner) => {
+		const target = findResource(packageId, resourceId);
+		if (target && expectedKinds.includes(target.kind)) return;
+		issues.push({
+			severity: "error",
+			code: "dangling_resource_reference",
+			path,
+			message: `Resource reference "${packageId}/${resourceId}" must target ${expectedKinds.join(" or ")}.`,
+			...owner
+		});
+	};
+	const pushMissingUi = (path, value, expectedKinds, owner) => {
+		if (!value.startsWith("ui://")) return;
+		const target = findUiResource(project, value);
+		if (target && expectedKinds.includes(target.kind)) return;
+		issues.push({
+			severity: "error",
+			code: "dangling_resource_reference",
+			path,
+			message: `Resource reference "${value}" must target ${expectedKinds.join(" or ")}.`,
+			...owner
+		});
+	};
+	const componentKinds = ["component"];
+	const visualKinds = [
+		"image",
+		"movieClip",
+		"component",
+		"spine",
+		"dragonBones"
+	];
+	const binaryKinds = [
+		"image",
+		"sound",
+		"misc",
+		"font",
+		"movieClip",
+		"spine",
+		"dragonBones"
+	];
+	const resourceKinds = [...binaryKinds, "component"];
+	for (const [packageIndex, pkg] of project.packages.entries()) for (const [resourceIndex, resource] of pkg.resources.entries()) {
+		const resourcePath = `packages[${packageIndex}].resources[${resourceIndex}]`;
+		const owner = {
+			packageId: pkg.id,
+			resourceId: resource.id
+		};
+		if (resource.kind === "font") {
+			const textureId = `${resource.metadata?.textureId ?? ""}`;
+			if (textureId) pushMissing(`${resourcePath}.metadata.textureId`, pkg.id, textureId, ["image"], owner);
+		}
+		if (resource.kind === "spine" || resource.kind === "dragonBones") {
+			const requireIds = Array.isArray(resource.metadata?.requireIds) ? resource.metadata.requireIds.filter((value) => typeof value === "string") : [];
+			for (const [requireIndex, requireId] of requireIds.entries()) pushMissing(`${resourcePath}.metadata.requireIds[${requireIndex}]`, pkg.id, requireId, binaryKinds, owner);
+		}
+		if (resource.kind !== "component") continue;
+		const componentPath = `${resourcePath}.component`;
+		for (const [field, value] of [
+			["vtScrollBarRes", resource.component.properties.vtScrollBarRes],
+			["hzScrollBarRes", resource.component.properties.hzScrollBarRes],
+			["headerRes", resource.component.properties.headerRes],
+			["footerRes", resource.component.properties.footerRes],
+			["dropdown", resource.component.properties.dropdown]
+		]) pushMissingUi(`${componentPath}.properties.${field}`, value, componentKinds, owner);
+		pushMissingUi(`${componentPath}.properties.sound`, resource.component.properties.sound, ["sound"], owner);
+		for (const [nodeIndex, node] of resource.component.displayList.entries()) {
+			const nodePath = `${componentPath}.displayList[${nodeIndex}]`;
+			const nodeOwner = {
+				...owner,
+				nodeId: node.id
+			};
+			if (node.kind === "image" && node.resource.resourceId) pushMissing(`${nodePath}.resource`, node.resource.packageId || pkg.id, node.resource.resourceId, ["image"], nodeOwner);
+			else if (node.kind === "movieClip" && node.resource.resourceId) pushMissing(`${nodePath}.resource`, node.resource.packageId || pkg.id, node.resource.resourceId, ["movieClip"], nodeOwner);
+			else if (node.kind === "component" && node.resource.resourceId) pushMissing(`${nodePath}.resource`, node.resource.packageId || pkg.id, node.resource.resourceId, componentKinds, nodeOwner);
+			else if ("packageId" in node && "src" in node && node.src) pushMissing(`${nodePath}.src`, node.packageId || pkg.id, node.src, componentKinds, nodeOwner);
+			if (node.kind === "text" || node.kind === "richText" || node.kind === "textInput") {
+				pushMissingUi(`${nodePath}.font`, node.font, ["font"], nodeOwner);
+				for (const [index, reference] of collectUiReferences(node.text).entries()) pushMissingUi(`${nodePath}.text[${index}]`, reference, resourceKinds, nodeOwner);
+			}
+			if (node.kind === "loader" || node.kind === "loader3D") pushMissingUi(`${nodePath}.url`, node.url, visualKinds, nodeOwner);
+			if (node.kind === "list" || node.kind === "tree") {
+				for (const [field, value] of [
+					["defaultItem", node.defaultItem],
+					["src", node.src],
+					["vtScrollBarRes", node.vtScrollBarRes],
+					["hzScrollBarRes", node.hzScrollBarRes],
+					["headerRes", node.headerRes],
+					["footerRes", node.footerRes]
+				]) pushMissingUi(`${nodePath}.${field}`, value, componentKinds, nodeOwner);
+				for (const [itemIndex, item] of node.listItems.entries()) {
+					pushMissingUi(`${nodePath}.listItems[${itemIndex}].url`, item.url ?? "", componentKinds, nodeOwner);
+					pushMissingUi(`${nodePath}.listItems[${itemIndex}].icon`, item.icon ?? "", visualKinds, nodeOwner);
+					pushMissingUi(`${nodePath}.listItems[${itemIndex}].selectedIcon`, item.selectedIcon ?? "", visualKinds, nodeOwner);
+				}
+			}
+			if (node.kind === "component" && node.instanceProperties) {
+				const instance = node.instanceProperties;
+				if ("icon" in instance) pushMissingUi(`${nodePath}.instanceProperties.icon`, instance.icon, visualKinds, nodeOwner);
+				if (instance.extensionType === "Button") {
+					pushMissingUi(`${nodePath}.instanceProperties.selectedIcon`, instance.selectedIcon, visualKinds, nodeOwner);
+					pushMissingUi(`${nodePath}.instanceProperties.sound`, instance.sound, ["sound"], nodeOwner);
+				}
+				if (instance.extensionType === "ComboBox") for (const [itemIndex, item] of instance.items.entries()) pushMissingUi(`${nodePath}.instanceProperties.items[${itemIndex}].icon`, item.icon ?? "", visualKinds, nodeOwner);
+			}
+			if ("icon" in node) pushMissingUi(`${nodePath}.icon`, node.icon, visualKinds, nodeOwner);
+			if ("selectedIcon" in node) pushMissingUi(`${nodePath}.selectedIcon`, node.selectedIcon, visualKinds, nodeOwner);
+			if ("icons" in node) for (const [iconIndex, icon] of node.icons.entries()) pushMissingUi(`${nodePath}.icons[${iconIndex}]`, icon, visualKinds, nodeOwner);
+			if ("sound" in node) pushMissingUi(`${nodePath}.sound`, node.sound, ["sound"], nodeOwner);
+			for (const [gearIndex, gear] of node.gears.entries()) for (const [index, reference] of collectUiReferences(gear).entries()) pushMissingUi(`${nodePath}.gears[${gearIndex}][${index}]`, reference, resourceKinds, nodeOwner);
+		}
+		for (const [transitionIndex, transition] of resource.component.transitions.entries()) for (const [itemIndex, item] of transition.items.entries()) for (const [field, value] of [["startValue", item.startValue], ["endValue", item.endValue]]) for (const [index, reference] of collectUiReferences(value).entries()) pushMissingUi(`${componentPath}.transitions[${transitionIndex}].items[${itemIndex}].${field}[${index}]`, reference, resourceKinds, owner);
+	}
+	return issues;
+}
+//#endregion
+//#region ../core/src/uam/project-source-files.ts
+function defaultAssetSourcePath(resource) {
+	const fileName = resource.fileName ?? (resource.kind === "image" ? "" : resource.file) ?? "";
+	return `/${[resource.path.replace(/\\/g, "/").replace(/^\/+|\/+$/g, ""), fileName].filter(Boolean).join("/")}`;
+}
+//#endregion
+//#region ../core/src/uam/source-validation.ts
+function assetFileName(resource) {
+	return resource.fileName ?? (resource.kind === "image" ? "" : resource.file) ?? resource.name;
+}
+function sourceExtension(resource) {
+	const fileName = assetFileName(resource);
+	const dot = fileName.lastIndexOf(".");
+	return dot < 0 ? "" : fileName.slice(dot + 1).toLowerCase();
+}
+function validSvg(bytes) {
+	try {
+		if (bytes.byteLength === 0 || bytes.byteLength > 8 * 1024 * 1024) return false;
+		const source = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+		if (XMLValidator.validate(source, { allowBooleanAttributes: false }) !== true) return false;
+		if (!/<svg(?:\s|>)/i.test(source)) return false;
+		if (/<!\s*(?:doctype|entity)\b|<\?xml-stylesheet\b/iu.test(source)) return false;
+		if (/<(?:a|animate|animatecolor|animatemotion|animatetransform|audio|canvas|discard|embed|feimage|foreignobject|iframe|image|object|script|set|style|video)(?:\s|>)/iu.test(source)) return false;
+		if (/\s(?:on[\w:-]*|style|src)\s*=/iu.test(source)) return false;
+		if (/\s(?:href|xlink:href)\s*=\s*['"](?!#[A-Za-z_][\w:.-]*['"])/iu.test(source)) return false;
+		return !/(?:https?:|file:|javascript:|data:|\/\/)|url\s*\(\s*(?!['"]?#[A-Za-z_])/iu.test(source);
+	} catch {
+		return false;
+	}
+}
+function validateUamSourceBytes(project) {
+	const diagnostics = [];
+	let complete = true;
+	for (const [packageIndex, pkg] of project.packages.entries()) for (const [resourceIndex, resource] of pkg.resources.entries()) {
+		if (resource.kind === "component") continue;
+		const bytes = resource.sourceBytes;
+		const path = `packages[${packageIndex}].resources[${resourceIndex}]`;
+		const sourcePath = resource.sourcePath ?? defaultAssetSourcePath(resource);
+		const base = {
+			path,
+			packageId: pkg.id,
+			resourceId: resource.id,
+			sourcePath
+		};
+		if (!(bytes instanceof Uint8Array)) {
+			complete = false;
+			diagnostics.push({
+				severity: "warning",
+				code: "decode_capability_unavailable",
+				message: "Source bytes are not loaded, so source validation is incomplete.",
+				...base
+			});
+			continue;
+		}
+		if (bytes.byteLength === 0) {
+			diagnostics.push({
+				severity: "error",
+				code: "corrupt_source",
+				message: "Declared source file is empty.",
+				...base
+			});
+			continue;
+		}
+		if (resource.kind === "image") {
+			const extension = sourceExtension(resource);
+			if (extension === "png" || extension === "jpg" || extension === "jpeg") {
+				if (!probeRasterImage(bytes)) diagnostics.push({
+					severity: "error",
+					code: "corrupt_source",
+					message: `Invalid ${extension.toUpperCase()} source.`,
+					...base
+				});
+			} else if (extension === "svg") {
+				if (!validSvg(bytes)) diagnostics.push({
+					severity: "error",
+					code: "corrupt_source",
+					message: "Invalid or unsafe SVG source.",
+					...base
+				});
+			} else {
+				complete = false;
+				diagnostics.push({
+					severity: "warning",
+					code: "decode_capability_unavailable",
+					message: `No host-neutral decoder is available for image extension "${extension || "(none)"}".`,
+					...base
+				});
+			}
+		} else if (resource.kind === "movieClip") try {
+			deriveMovieClipModelFromJta(bytes);
+		} catch (error) {
+			diagnostics.push({
+				severity: "error",
+				code: "corrupt_source",
+				message: `Invalid MovieClip source: ${error instanceof Error ? error.message : String(error)}`,
+				...base
+			});
+		}
+	}
+	return {
+		diagnostics,
+		complete
+	};
+}
+//#endregion
+//#region ../core/src/uam/bridge-materialize.ts
+function parseNumber(raw, fallback) {
+	if (raw === void 0 || raw === "") return fallback;
+	const value = Number(raw);
+	return Number.isFinite(value) ? value : fallback;
+}
+function parseBool(raw, fallback) {
+	if (raw === void 0 || raw === "") return fallback;
+	const normalized = raw.toLowerCase();
+	if (normalized === "1" || normalized === "true" || normalized === "p") return true;
+	if (normalized === "0" || normalized === "false" || normalized === "s") return false;
+	return fallback;
+}
+function parseLookGearValue(value) {
+	if (!value || value === "-") return null;
+	const parts = value.split(",");
+	return {
+		alpha: parseNumber(parts[0], 1),
+		rotation: parseNumber(parts[1], 0),
+		grayed: parseBool(parts[2], false),
+		touchable: parseBool(parts[3], true)
+	};
+}
+function parseGenericGearValue(kind, value) {
+	if (!value || value === "-") return null;
+	const parts = value.split(",");
+	switch (kind) {
+		case "xy": return {
+			x: parseNumber(parts[0], 0),
+			y: parseNumber(parts[1], 0)
+		};
+		case "size": return {
+			width: parseNumber(parts[0], 0),
+			height: parseNumber(parts[1], 0),
+			scaleX: parseNumber(parts[2], 1),
+			scaleY: parseNumber(parts[3], 1)
+		};
+		case "color": return {
+			color: parts[0] || "#ffffff",
+			outlineColor: parts[1] || null
+		};
+		case "animation": return {
+			frame: parseNumber(parts[0], 0),
+			playing: parseBool(parts[1], true),
+			animationName: parts[2] ?? "",
+			skinName: parts[3] ?? ""
+		};
+		case "text": return { text: value };
+		case "icon": return { icon: value };
+		case "fontSize": return { fontSize: parseNumber(parts[0], 12) };
+	}
+}
+function defaultGenericGearValue(kind) {
+	switch (kind) {
+		case "xy": return {
+			x: 0,
+			y: 0
+		};
+		case "size": return {
+			width: 0,
+			height: 0,
+			scaleX: 1,
+			scaleY: 1
+		};
+		case "color": return {
+			color: "#ffffff",
+			outlineColor: null
+		};
+		case "animation": return {
+			frame: 0,
+			playing: true,
+			animationName: "",
+			skinName: ""
+		};
+		case "text": return { text: "" };
+		case "icon": return { icon: "" };
+		case "fontSize": return { fontSize: 12 };
+	}
+}
+//#endregion
+//#region ../core/src/uam/bridge-lift.ts
+function liftDisplayNodeBase(child) {
+	return {
+		id: child.getId(),
+		name: child.getName(),
+		position: {
+			x: child.getX(),
+			y: child.getY()
+		},
+		size: {
+			width: child.getWidth(),
+			height: child.getHeight()
+		},
+		locked: child.getLocked(),
+		aspect: child.getAspect(),
+		minSize: {
+			width: child.getMinWidth(),
+			height: child.getMinHeight()
+		},
+		maxSize: {
+			width: child.getMaxWidth(),
+			height: child.getMaxHeight()
+		},
+		pivot: {
+			x: child.getPivotX(),
+			y: child.getPivotY()
+		},
+		pivotAsAnchor: child.getPivotAsAnchor(),
+		scale: {
+			x: child.getScaleX(),
+			y: child.getScaleY()
+		},
+		skew: {
+			x: child.getSkewX(),
+			y: child.getSkewY()
+		},
+		visible: child.getVisible(),
+		touchable: child.getTouchable(),
+		grayed: child.getGrayed(),
+		alpha: child.getAlpha(),
+		rotation: child.getRotation(),
+		tooltips: child.getTooltips(),
+		blendMode: child.getBlendMode(),
+		filter: child.getFilter(),
+		filterData: child.getFilterData(),
+		customData: child.getCustomData(),
+		relations: liftRelations(child.getRelations()),
+		gears: liftGears(child.listGears())
+	};
+}
+function liftComponentDerivedControlBase(child) {
+	return {
+		...liftDisplayNodeBase(child),
+		group: child.getGroup(),
+		src: child.getSrc(),
+		packageId: child.getPackageId()
+	};
+}
+function liftTitleControlBase(child) {
+	return {
+		...liftComponentDerivedControlBase(child),
+		title: child.getTitle(),
+		icon: child.getIcon(),
+		titleColor: child.getTitleColor(),
+		titleFontSize: child.getTitleFontSize(),
+		sound: child.getSound(),
+		soundVolumeScale: child.getSoundVolumeScale()
+	};
+}
+function liftAssetSourceData(resource) {
+	const buffer = resource.getSourceData?.();
+	if (!buffer) return {};
+	const sourceBytes = buffer.getData();
+	return {
+		...sourceBytes ? { sourceBytes: new Uint8Array(sourceBytes) } : { sourceBytes: null },
+		...buffer.getURI() ? { sourcePath: buffer.getURI() } : {}
+	};
+}
+function baseAssetResource(kind, resource) {
+	return {
+		kind,
+		id: resource.getId(),
+		name: resource.getName(),
+		path: resource.getPath(),
+		exported: resource.getExported(),
+		favorite: resource.getFavorite(),
+		branch: resource.getBranch(),
+		branchItemIds: resource.getBranchItemIds(),
+		...liftAssetSourceData(resource)
+	};
+}
+function liftAssetResource(resource) {
+	if (resource.propertyType === PropertyType.IMAGE_RESOURCE) {
+		const image = resource;
+		const scale9Grid = image.getScale9Grid();
+		return {
+			...baseAssetResource("image", image),
+			fileName: image.getFileName(),
+			dimensions: {
+				width: image.getWidth(),
+				height: image.getHeight()
+			},
+			image: {
+				textureSetMode: image.getTextureSetMode(),
+				qualityOption: image.getQualityOption(),
+				quality: image.getQuality(),
+				smoothing: image.getSmoothing(),
+				duplicatePadding: image.getDuplicatePadding(),
+				scaleOption: image.getScaleOption(),
+				scale9Grid: scale9Grid ? [...scale9Grid] : null,
+				tileGridIndice: image.getTileGridIndice()
+			}
+		};
+	}
+	if (resource.propertyType === PropertyType.MOVIE_CLIP_RESOURCE) {
+		const movieClip = resource;
+		return {
+			...baseAssetResource("movieClip", movieClip),
+			fileName: movieClip.getFileName(),
+			dimensions: {
+				width: movieClip.getWidth(),
+				height: movieClip.getHeight()
+			},
+			movieClip: {
+				interval: movieClip.getInterval(),
+				repeatDelay: movieClip.getRepeatDelay(),
+				swing: movieClip.getSwing(),
+				smoothing: movieClip.getSmoothing(),
+				frames: movieClip.listFrames().map((frame) => ({
+					rectX: frame.getRectX(),
+					rectY: frame.getRectY(),
+					rectWidth: frame.getRectWidth(),
+					rectHeight: frame.getRectHeight(),
+					addDelay: frame.getAddDelay(),
+					spriteId: frame.getSpriteId()
+				}))
+			}
+		};
+	}
+	if (resource.propertyType === PropertyType.SOUND_RESOURCE) {
+		const sound = resource;
+		return {
+			...baseAssetResource("sound", sound),
+			file: sound.getFile()
+		};
+	}
+	if (resource.propertyType === PropertyType.MISC_RESOURCE) {
+		const misc = resource;
+		return {
+			...baseAssetResource("misc", misc),
+			file: misc.getFile()
+		};
+	}
+	if (resource.propertyType === PropertyType.FONT_RESOURCE) {
+		const font = resource;
+		return {
+			...baseAssetResource("font", font),
+			fileName: font.getFileName(),
+			metadata: {
+				textureId: font.getTextureId(),
+				renderMode: font.getRenderMode(),
+				samplePointSize: font.getSamplePointSize(),
+				ttf: font.getTtf(),
+				tint: font.getTint(),
+				autoScale: font.getAutoScale(),
+				hasChannel: font.getHasChannel(),
+				fontSize: font.getFontSize(),
+				xAdvance: font.getXAdvance(),
+				lineHeight: font.getLineHeight()
+			}
+		};
+	}
+	if (resource.propertyType === PropertyType.SPINE_RESOURCE || resource.propertyType === PropertyType.DRAGON_BONES_RESOURCE) {
+		const skeleton = resource;
+		return {
+			...baseAssetResource(resource.propertyType === PropertyType.SPINE_RESOURCE ? "spine" : "dragonBones", skeleton),
+			file: skeleton.getFile(),
+			dimensions: {
+				width: skeleton.getWidth(),
+				height: skeleton.getHeight()
+			},
+			metadata: {
+				requireIds: skeleton.getRequireIds(),
+				atlasNames: skeleton.getAtlasNames(),
+				anchorX: skeleton.getAnchorX(),
+				anchorY: skeleton.getAnchorY()
+			}
+		};
+	}
+	throw new Error(`UAM lift does not support resource type "${resource.propertyType}" in Gate A.`);
+}
+function liftGears(gears) {
+	return gears.map((gear) => {
+		const pages = gear.getPages() ? gear.getPages().split(",") : [];
+		if (gear.getGearType() === GearType.Display) return {
+			kind: "display",
+			name: gear.getName(),
+			controllerName: gear.getController()?.getName() ?? "",
+			visibleOnPageIds: pages
+		};
+		if (gear.getGearType() === GearType.Display2) return {
+			kind: "display2",
+			name: gear.getName(),
+			controllerName: gear.getController()?.getName() ?? "",
+			visibleOnPageIds: pages,
+			condition: gear.getCondition()
+		};
+		if (gear.getGearType() !== GearType.Look) {
+			const kind = new Map([
+				[GearType.XY, "xy"],
+				[GearType.Size, "size"],
+				[GearType.Color, "color"],
+				[GearType.Animation, "animation"],
+				[GearType.Text, "text"],
+				[GearType.Icon, "icon"],
+				[GearType.FontSize, "fontSize"]
+			]).get(gear.getGearType());
+			if (!kind) throw new Error(`UAM lift does not support gear type "${gear.getGearType()}" in Gate A.`);
+			const values = gear.getValues() ? gear.getValues().split("|") : [];
+			const defaultValue = `${gear.getDefaultValue() ?? ""}`;
+			const base = {
+				name: gear.getName(),
+				controllerName: gear.getController()?.getName() ?? "",
+				states: pages.map((pageId, index) => ({
+					pageId,
+					value: parseGenericGearValue(kind, values[index] ?? null)
+				})),
+				defaultValue: parseGenericGearValue(kind, defaultValue) ?? defaultGenericGearValue(kind),
+				condition: gear.getCondition(),
+				positionsInPercent: gear.getPositionsInPercent(),
+				tween: gear.getTween(),
+				tweenDuration: gear.getTweenDuration(),
+				tweenDelay: gear.getTweenDelay(),
+				easeType: gear.getEaseType(),
+				customEasePath: gear.getCustomEasePath()
+			};
+			switch (kind) {
+				case "xy": return {
+					kind,
+					...base
+				};
+				case "size": return {
+					kind,
+					...base
+				};
+				case "color": return {
+					kind,
+					...base
+				};
+				case "animation": return {
+					kind,
+					...base
+				};
+				case "text": return {
+					kind,
+					...base
+				};
+				case "icon": return {
+					kind,
+					...base
+				};
+				case "fontSize": return {
+					kind,
+					...base
+				};
+			}
+		}
+		const values = gear.getValues() ? gear.getValues().split("|") : [];
+		const defaultValue = `${gear.getDefaultValue() ?? ""}`;
+		return {
+			kind: "look",
+			name: gear.getName(),
+			controllerName: gear.getController()?.getName() ?? "",
+			states: pages.map((pageId, index) => ({
+				pageId,
+				value: parseLookGearValue(values[index] ?? null)
+			})),
+			defaultValue: parseLookGearValue(defaultValue) ?? {
+				alpha: 1,
+				rotation: 0,
+				grayed: false,
+				touchable: true
+			},
+			condition: gear.getCondition(),
+			positionsInPercent: gear.getPositionsInPercent(),
+			tween: gear.getTween(),
+			tweenDuration: gear.getTweenDuration(),
+			tweenDelay: gear.getTweenDelay(),
+			easeType: gear.getEaseType(),
+			customEasePath: gear.getCustomEasePath()
+		};
+	});
+}
+function liftDisplayNode(child) {
+	if (child.propertyType === PropertyType.G_IMAGE) {
+		const image = child;
+		return {
+			kind: "image",
+			...liftDisplayNodeBase(image),
+			group: image.getGroup(),
+			resource: { resourceId: image.getSrc() }
+		};
+	}
+	if (child.propertyType === PropertyType.G_TEXT_FIELD || child.propertyType === PropertyType.G_RICH_TEXT_FIELD || child.propertyType === PropertyType.G_TEXT_INPUT) {
+		const text = child;
+		const textProperties = {
+			text: text.getText(),
+			font: text.getFont(),
+			fontSize: text.getFontSize(),
+			color: text.getColor(),
+			align: text.getAlign(),
+			vAlign: text.getVAlign(),
+			leading: text.getLeading(),
+			letterSpacing: text.getLetterSpacing(),
+			autoSize: text.getAutoSize(),
+			singleLine: text.getSingleLine(),
+			autoClearText: text.getAutoClearText(),
+			underlaySoftness: text.getUnderlaySoftness(),
+			ubbEnabled: text.getUbbEnabled(),
+			underline: text.getUnderline(),
+			italic: text.getItalic(),
+			bold: text.getBold(),
+			strikethrough: text.getStrikethrough(),
+			strokeColor: text.getStrokeColor(),
+			strokeSize: text.getStrokeSize(),
+			shadowColor: text.getShadowColor(),
+			shadowOffset: text.getShadowOffset()
+		};
+		const plainTextProperties = {
+			...textProperties,
+			demoText: text.getDemoText(),
+			templateVarsEnabled: text.getTemplateVarsEnabled(),
+			faceDilate: text.getFaceDilate()
+		};
+		const base = {
+			...liftDisplayNodeBase(text),
+			group: text.getGroup()
+		};
+		if (child.propertyType === PropertyType.G_RICH_TEXT_FIELD) return {
+			kind: "richText",
+			...base,
+			...textProperties
+		};
+		if (child.propertyType === PropertyType.G_TEXT_INPUT) {
+			const input = child;
+			return {
+				kind: "textInput",
+				...base,
+				...plainTextProperties,
+				promptText: input.getPromptText(),
+				maxLength: input.getMaxLength(),
+				restrict: input.getRestrict(),
+				password: input.getPassword(),
+				keyboardType: input.getKeyboardType()
+			};
+		}
+		return {
+			kind: "text",
+			...base,
+			...plainTextProperties
+		};
+	}
+	if (child.propertyType === PropertyType.G_COMPONENT) {
+		const component = child;
+		const instanceProperties = liftComponentInstanceProperties(component);
+		const propertyOverrides = component.getPropertyOverrides();
+		return {
+			kind: "component",
+			...liftDisplayNodeBase(component),
+			group: component.getGroup(),
+			resource: {
+				packageId: component.getPackageId(),
+				resourceId: component.getSrc()
+			},
+			...propertyOverrides.length > 0 ? { propertyOverrides } : {},
+			...instanceProperties ? { instanceProperties } : {}
+		};
+	}
+	if (child.propertyType === PropertyType.G_LIST || child.propertyType === PropertyType.G_TREE) {
+		const list = child;
+		const base = {
+			...liftDisplayNodeBase(list),
+			group: list.getGroup(),
+			layout: list.getLayout(),
+			align: list.getAlign(),
+			vAlign: list.getVAlign(),
+			lineGap: list.getLineGap(),
+			columnGap: list.getColumnGap(),
+			lineCount: list.getLineCount(),
+			columnCount: list.getColumnCount(),
+			selectionMode: list.getSelectionMode(),
+			defaultItem: list.getDefaultItem(),
+			autoResizeItem: list.getAutoResizeItem(),
+			childrenRenderOrder: list.getChildrenRenderOrder(),
+			apexIndex: list.getApexIndex(),
+			src: list.getSrc(),
+			overflow: list.getOverflow(),
+			scrollType: list.getScrollType(),
+			scrollBarFlags: list.getScrollBarFlags(),
+			scrollBarMargin: liftEdgeInsets(list.getScrollBarMargin()),
+			vtScrollBarRes: list.getVtScrollBarRes(),
+			hzScrollBarRes: list.getHzScrollBarRes(),
+			headerRes: list.getHeaderRes(),
+			footerRes: list.getFooterRes(),
+			margin: liftEdgeInsets(list.getMargin()),
+			clipSoftness: list.getClipSoftness(),
+			scrollItemToViewOnClick: list.getScrollItemToViewOnClick(),
+			foldInvisibleItems: list.getFoldInvisibleItems(),
+			autoClearItems: list.getAutoClearItems(),
+			listItems: cloneListItems(list.getListItems()),
+			pageController: list.getPageController(),
+			controllerOverrides: list.getControllerOverrides(),
+			selectionController: list.getSelectionController()
+		};
+		if (child.propertyType === PropertyType.G_TREE) {
+			const tree = child;
+			return {
+				kind: "tree",
+				...base,
+				treeView: tree.getTreeView(),
+				indent: tree.getIndent(),
+				clickToExpand: tree.getClickToExpand()
+			};
+		}
+		return {
+			kind: "list",
+			...base
+		};
+	}
+	if (child.propertyType === PropertyType.G_GRAPH) {
+		const graph = child;
+		return {
+			kind: "graph",
+			...liftDisplayNodeBase(graph),
+			pivot: {
+				x: graph.getPivotX(),
+				y: graph.getPivotY()
+			},
+			pivotAsAnchor: graph.getPivotAsAnchor(),
+			group: graph.getGroup(),
+			graphType: graph.getGraphType(),
+			lineSize: graph.getLineSize(),
+			lineColor: graph.getLineColor(),
+			fillColor: graph.getFillColor(),
+			cornerRadius: graph.getCornerRadius(),
+			points: graph.getPoints(),
+			sides: graph.getSides(),
+			startAngle: graph.getStartAngle(),
+			distances: graph.getDistances()
+		};
+	}
+	if (child.propertyType === PropertyType.G_GROUP) {
+		const group = child;
+		return {
+			kind: "group",
+			...liftDisplayNodeBase(group),
+			group: group.getGroup(),
+			layout: group.getLayout(),
+			lineGap: group.getLineGap(),
+			columnGap: group.getColumnGap(),
+			advanced: group.getAdvanced(),
+			excludeInvisibles: group.getExcludeInvisibles(),
+			autoSizeDisabled: group.getAutoSizeDisabled(),
+			mainGridIndex: group.getMainGridIndex()
+		};
+	}
+	if (child.propertyType === PropertyType.G_LOADER) {
+		const loader = child;
+		return {
+			kind: "loader",
+			...liftDisplayNodeBase(loader),
+			pivot: {
+				x: loader.getPivotX(),
+				y: loader.getPivotY()
+			},
+			url: loader.getUrl(),
+			fill: loader.getFill(),
+			shrinkOnly: loader.getShrinkOnly(),
+			autoSize: loader.getAutoSize(),
+			useResize: loader.getUseResize(),
+			align: loader.getAlign(),
+			vAlign: loader.getVAlign(),
+			frame: loader.getFrame(),
+			playing: loader.getPlaying(),
+			color: loader.getColor(),
+			fillMethod: loader.getFillMethod(),
+			fillOrigin: loader.getFillOrigin(),
+			fillClockwise: loader.getFillClockwise(),
+			fillAmount: loader.getFillAmount(),
+			clearOnPublish: loader.getClearOnPublish()
+		};
+	}
+	if (child.propertyType === PropertyType.G_LOADER_3D) {
+		const loader = child;
+		return {
+			kind: "loader3D",
+			...liftDisplayNodeBase(loader),
+			url: loader.getUrl(),
+			fill: loader.getFill(),
+			shrinkOnly: loader.getShrinkOnly(),
+			autoSize: loader.getAutoSize(),
+			align: loader.getAlign(),
+			vAlign: loader.getVAlign(),
+			animationName: loader.getAnimationName(),
+			skinName: loader.getSkinName(),
+			playing: loader.getPlaying(),
+			frame: loader.getFrame(),
+			loop: loader.getLoop(),
+			color: loader.getColor(),
+			clearOnPublish: loader.getClearOnPublish()
+		};
+	}
+	if (child.propertyType === PropertyType.G_BUTTON) {
+		const button = child;
+		return {
+			kind: "button",
+			...liftTitleControlBase(button),
+			selectedTitle: button.getSelectedTitle(),
+			selectedIcon: button.getSelectedIcon(),
+			mode: button.getMode(),
+			downEffect: button.getDownEffect(),
+			downEffectValue: button.getDownEffectValue()
+		};
+	}
+	if (child.propertyType === PropertyType.G_LABEL) return {
+		kind: "label",
+		...liftTitleControlBase(child)
+	};
+	if (child.propertyType === PropertyType.G_COMBO_BOX) {
+		const comboBox = child;
+		return {
+			kind: "comboBox",
+			...liftTitleControlBase(comboBox),
+			items: comboBox.getItems(),
+			icons: comboBox.getIcons(),
+			values: comboBox.getValues(),
+			selectedIndex: comboBox.getSelectedIndex(),
+			visibleItemCount: comboBox.getVisibleItemCount(),
+			popupDirection: comboBox.getPopupDirection()
+		};
+	}
+	if (child.propertyType === PropertyType.G_PROGRESS_BAR) {
+		const progressBar = child;
+		return {
+			kind: "progressBar",
+			...liftComponentDerivedControlBase(progressBar),
+			titleType: progressBar.getTitleType(),
+			min: progressBar.getMin(),
+			max: progressBar.getMax(),
+			value: progressBar.getValue(),
+			reverse: progressBar.getReverse(),
+			sound: progressBar.getSound(),
+			soundVolumeScale: progressBar.getSoundVolumeScale()
+		};
+	}
+	if (child.propertyType === PropertyType.G_SLIDER) {
+		const slider = child;
+		return {
+			kind: "slider",
+			...liftComponentDerivedControlBase(slider),
+			titleType: slider.getTitleType(),
+			min: slider.getMin(),
+			max: slider.getMax(),
+			value: slider.getValue(),
+			wholeNumbers: slider.getWholeNumbers()
+		};
+	}
+	if (child.propertyType === PropertyType.G_SCROLL_BAR) {
+		const scrollBar = child;
+		return {
+			kind: "scrollBar",
+			...liftComponentDerivedControlBase(scrollBar),
+			fixedGripSize: scrollBar.getFixedGripSize()
+		};
+	}
+	if (child.propertyType === PropertyType.G_MOVIE_CLIP) {
+		const movieClip = child;
+		return {
+			kind: "movieClip",
+			...liftDisplayNodeBase(movieClip),
+			group: movieClip.getGroup(),
+			resource: {
+				packageId: movieClip.getPackageId(),
+				resourceId: movieClip.getSrc()
+			},
+			fileName: movieClip.getFileName(),
+			playing: movieClip.getPlaying(),
+			frame: movieClip.getFrame(),
+			color: movieClip.getColor()
+		};
+	}
+	throw new Error(`UAM lift does not support display node type "${child.propertyType}" in Gate A.`);
+}
+function liftComponentInstanceProperties(component) {
+	switch (component.getInstanceExtType()) {
+		case "Button": return {
+			extensionType: "Button",
+			title: component.getInstanceTitle(),
+			selectedTitle: component.getInstanceSelectedTitle(),
+			icon: component.getInstanceIcon(),
+			selectedIcon: component.getInstanceSelectedIcon(),
+			titleColor: component.getInstanceTitleColor(),
+			titleFontSize: component.getInstanceTitleFontSize(),
+			controller: component.getInstanceController(),
+			page: component.getInstancePage(),
+			checked: component.getInstanceChecked(),
+			sound: component.getInstanceSound(),
+			soundVolumeScale: component.getInstanceSoundVolumeScale()
+		};
+		case "Label": return {
+			extensionType: "Label",
+			title: component.getInstanceTitle(),
+			icon: component.getInstanceIcon(),
+			titleColor: component.getInstanceTitleColor(),
+			titleFontSize: component.getInstanceTitleFontSize(),
+			promptText: component.getInstancePromptText()
+		};
+		case "ComboBox": return {
+			extensionType: "ComboBox",
+			title: component.getInstanceTitle(),
+			icon: component.getInstanceIcon(),
+			visibleItemCount: component.getInstanceVisibleItemCount(),
+			selectionController: component.getInstanceSelectionController(),
+			autoClearItems: component.getInstanceAutoClearItems(),
+			items: component.getInstanceComboItems().map((item) => ({ ...item }))
+		};
+		case "ProgressBar":
+		case "Slider": return {
+			extensionType: component.getInstanceExtType(),
+			value: component.getInstanceValue(),
+			max: component.getInstanceMax(),
+			min: component.getInstanceMin()
+		};
+		case "ScrollBar": return { extensionType: "ScrollBar" };
+		default: return;
+	}
+}
+function liftControllers(component) {
+	return component.listControllers().map((controller) => ({
+		name: controller.getName(),
+		selectedIndex: controller.getSelectedIndex(),
+		autoRadioGroupDepth: controller.getAutoRadioGroupDepth(),
+		pages: controller.listPages().map((page) => ({
+			id: page.getId(),
+			name: page.getName()
+		})),
+		actions: controller.listActions().map((action) => ({
+			name: action.getName(),
+			actionType: action.getActionType(),
+			fromPageIds: action.getFromPage(),
+			toPageIds: action.getToPage(),
+			transitionName: action.getTransitionName(),
+			playTimes: action.getPlayTimes(),
+			delay: action.getDelay(),
+			stopOnExit: action.getStopOnExit(),
+			targetNodeId: action.getObjectId(),
+			controllerName: action.getControllerName(),
+			targetPage: action.getTargetPage()
+		}))
+	}));
+}
+function liftTransitions(component) {
+	return component.listTransitions().map((transition) => ({
+		name: transition.getName(),
+		autoPlay: transition.getAutoPlay(),
+		autoPlayTimes: transition.getAutoPlayTimes(),
+		autoPlayDelay: transition.getAutoPlayDelay(),
+		options: transition.getOptions(),
+		fps: transition.getFps(),
+		items: transition.listItems().map((item) => ({
+			name: item.getName(),
+			time: item.getTime(),
+			actionType: item.getActionType(),
+			targetNodeId: item.getTargetId(),
+			tween: item.getTween(),
+			duration: item.getDuration(),
+			startValue: item.getStartValue(),
+			endValue: item.getEndValue(),
+			easeType: item.getEaseType(),
+			repeat: item.getRepeat(),
+			yoyo: item.getYoyo(),
+			label: item.getLabel(),
+			endLabel: item.getEndLabel(),
+			path: item.getPath(),
+			customEasePath: item.getCustomEasePath()
+		}))
+	}));
+}
+function liftComponentResource(resource) {
+	return {
+		kind: "component",
+		id: resource.getId(),
+		name: resource.getName(),
+		path: resource.getPath(),
+		exported: resource.getExported(),
+		favorite: resource.getFavorite(),
+		branch: resource.getBranch(),
+		branchItemIds: resource.getBranchItemIds(),
+		component: {
+			size: {
+				width: resource.getWidth(),
+				height: resource.getHeight()
+			},
+			properties: liftComponentProperties(resource),
+			customData: resource.getCustomData(),
+			displayList: resource.listChildren().map((child) => liftDisplayNode(child)),
+			controllers: liftControllers(resource),
+			transitions: liftTransitions(resource)
+		}
+	};
+}
+function liftComponentProperties(resource) {
+	return {
+		minSize: {
+			width: resource.getMinWidth(),
+			height: resource.getMinHeight()
+		},
+		maxSize: {
+			width: resource.getMaxWidth(),
+			height: resource.getMaxHeight()
+		},
+		pivot: {
+			x: resource.getPivotX(),
+			y: resource.getPivotY()
+		},
+		pivotAsAnchor: resource.getPivotAsAnchor(),
+		overflow: resource.getOverflow(),
+		margin: resource.getMargin(),
+		clipSoftness: resource.getClipSoftness(),
+		hitTest: resource.getHitTest(),
+		mask: resource.getMask(),
+		reversedMask: resource.getReversedMask(),
+		scrollType: resource.getScrollType(),
+		scrollBarDisplay: resource.getScrollBarDisplay(),
+		scrollBarFlags: resource.getScrollBarFlags(),
+		scrollBarMargin: resource.getScrollBarMargin(),
+		vtScrollBarRes: resource.getVtScrollBarRes(),
+		hzScrollBarRes: resource.getHzScrollBarRes(),
+		headerRes: resource.getHeaderRes(),
+		footerRes: resource.getFooterRes(),
+		bgColor: resource.getBgColor(),
+		bgColorEnabled: resource.getBgColorEnabled(),
+		designImageAlpha: resource.getDesignImageAlpha(),
+		designImageLayer: resource.getDesignImageLayer(),
+		designImageOffset: {
+			x: resource.getDesignImageOffsetX(),
+			y: resource.getDesignImageOffsetY()
+		},
+		idNum: resource.getIdNum(),
+		initName: resource.getInitName(),
+		remark: resource.getRemark(),
+		extensionType: resource.getExtensionType(),
+		opaque: resource.getOpaque(),
+		buttonMode: resource.getButtonMode(),
+		sound: resource.getSound(),
+		soundVolumeScale: resource.getSoundVolumeScale(),
+		downEffect: resource.getDownEffect(),
+		downEffectValue: resource.getDownEffectValue(),
+		dropdown: resource.getDropdown(),
+		promptText: resource.getPromptText(),
+		selectionController: resource.getSelectionController(),
+		titleType: resource.getTitleType(),
+		reverse: resource.getReverse(),
+		wholeNumbers: resource.getWholeNumbers(),
+		changeOnClick: resource.getChangeOnClick(),
+		fixedGripSize: resource.getFixedGripSize(),
+		autoClearItems: resource.getAutoClearItems(),
+		customProperties: resource.getCustomProperties()
+	};
+}
+function liftDocumentToUamProject(doc) {
+	const root = doc.getRoot();
+	return {
+		projectId: root.getProjectId(),
+		projectType: root.getProjectType(),
+		version: root.getVersion(),
+		branches: root.listBranches(),
+		settings: cloneSettings(root.getSettings()),
+		packages: root.listPackages().map((pkg) => {
+			const sourceAtlasSettings = pkg.getSourceAtlasSettings();
+			return {
+				id: pkg.getId(),
+				name: pkg.getName(),
+				compressPNG: pkg.getCompressPNG(),
+				jpegQuality: pkg.getJpegQuality(),
+				branchNames: pkg.listBranchNames(),
+				folders: pkg.listResourceFolders(),
+				publish: {
+					name: pkg.getPublishName(),
+					path: pkg.getPublishPath(),
+					branchPath: pkg.getPublishBranchPath(),
+					packageCount: pkg.getPublishPackageCount(),
+					genCode: pkg.getGenCode(),
+					codePath: pkg.getCodePath(),
+					useGlobalAtlasSettings: sourceAtlasSettings.useGlobal,
+					maxAtlasSize: sourceAtlasSettings.maxSize,
+					sizeOption: sourceAtlasSettings.sizeOption,
+					forceSquare: sourceAtlasSettings.forceSquare,
+					allowRotation: sourceAtlasSettings.allowRotation,
+					paging: sourceAtlasSettings.paging,
+					extractAlpha: sourceAtlasSettings.extractAlpha,
+					maxAtlasIndex: sourceAtlasSettings.maxIndex,
+					atlases: sourceAtlasSettings.atlases,
+					excludedResourceIds: sourceAtlasSettings.excludedResourceIds
+				},
+				resources: pkg.listResources().map((resource) => {
+					if (resource.propertyType === "Component") return liftComponentResource(resource);
+					return liftAssetResource(resource);
+				})
+			};
+		})
+	};
+}
+//#endregion
 //#region ../core/src/io/project-xml-protocol.ts
 const mergeAttrs = (...parts) => Object.assign({}, ...parts);
 const mergeChildren = (...parts) => Object.assign({}, ...parts);
@@ -16842,16 +18534,21 @@ var ReaderContext = class {
 	logger;
 	basePath;
 	settings = {};
+	diagnostics;
 	/** packageId → Package */
 	packageMap = /* @__PURE__ */ new Map();
 	/** packageId+resourceId → Property (ImageResource, Component, etc.) */
 	resourceMap = /* @__PURE__ */ new Map();
 	/** packageId+controllerName → Controller (for gear resolution within a component) */
 	controllerMap = /* @__PURE__ */ new Map();
-	constructor(document, basePath) {
+	constructor(document, basePath, diagnostics = []) {
 		this.document = document;
 		this.logger = document.getLogger();
 		this.basePath = basePath;
+		this.diagnostics = diagnostics;
+	}
+	addDiagnostic(diagnostic) {
+		this.diagnostics.push(diagnostic);
 	}
 	registerResource(packageId, resourceId, property) {
 		this.resourceMap.set(packageId + resourceId, property);
@@ -17011,10 +18708,10 @@ function getProtocolExtensionChildNames(protocol) {
 function getDisplayListVariantName$1(tagName, attrs) {
 	if (tagName === "loader3d") return "loader3D";
 	if (tagName === "text") {
-		if (parseBool(readXmlAttr(attrs, PROJECT_XML_PROTOCOL.text.attrs.input))) return "inputtext";
+		if (parseBool$1(readXmlAttr(attrs, PROJECT_XML_PROTOCOL.text.attrs.input))) return "inputtext";
 	}
 	if (tagName === "list") {
-		if (parseBool(readXmlAttr(attrs, PROJECT_XML_PROTOCOL.list.attrs.treeView))) return "tree";
+		if (parseBool$1(readXmlAttr(attrs, PROJECT_XML_PROTOCOL.list.attrs.treeView))) return "tree";
 	}
 	return tagName;
 }
@@ -17045,7 +18742,7 @@ function parseListItemXmlNode(item) {
 		selectedTitle: readXmlAttr(item, specs.selectedTitle) ?? null,
 		selectedIcon: readXmlAttr(item, specs.selectedIcon) ?? null,
 		level: parseInt2(readXmlAttr(item, specs.level)),
-		isFolder: isFolder !== void 0 ? parseBool(isFolder) : null,
+		isFolder: isFolder !== void 0 ? parseBool$1(isFolder) : null,
 		...controllers !== void 0 ? { controllers } : {},
 		...propertyOverrides.length > 0 ? { propertyOverrides } : {}
 	};
@@ -17071,19 +18768,19 @@ function readCommonDisplayState(source, object, protocol) {
 		object.setSize?.(width, height);
 	}
 	const locked = specs.locked ? readXmlAttr(source, specs.locked) : void 0;
-	if (locked !== void 0) object.setLocked(parseBool(locked));
+	if (locked !== void 0) object.setLocked(parseBool$1(locked));
 	const restrictSize = specs.restrictSize ? readXmlAttr(source, specs.restrictSize) : void 0;
 	if (restrictSize) {
 		const [minWidth = 0, maxWidth = 0, minHeight = 0, maxHeight = 0] = restrictSize.split(",").map((value) => parseFloat2(value));
 		object.setMinWidth(minWidth).setMaxWidth(maxWidth).setMinHeight(minHeight).setMaxHeight(maxHeight);
 	}
 	const aspect = specs.aspect ? readXmlAttr(source, specs.aspect) : void 0;
-	if (aspect !== void 0) object.setAspect(parseBool(aspect));
+	if (aspect !== void 0) object.setAspect(parseBool$1(aspect));
 	const pivot = specs.pivot ? readXmlAttr(source, specs.pivot) : void 0;
 	if (pivot) {
 		const [pivotX, pivotY] = parseXYString(pivot);
 		const anchor = specs.anchor ? readXmlAttr(source, specs.anchor) : void 0;
-		object.setPivot(pivotX, pivotY, parseBool(anchor));
+		object.setPivot(pivotX, pivotY, parseBool$1(anchor));
 	}
 	const scale = specs.scale ? readXmlAttr(source, specs.scale) : void 0;
 	if (scale) {
@@ -17102,11 +18799,11 @@ function readCommonDisplayState(source, object, protocol) {
 	const rotation = specs.rotation ? readXmlAttr(source, specs.rotation) : void 0;
 	if (rotation !== void 0) object.setRotation?.(parseFloat2(rotation));
 	const visible = specs.visible ? readXmlAttr(source, specs.visible) : void 0;
-	if (visible !== void 0) object.setVisible?.(parseBool(visible));
+	if (visible !== void 0) object.setVisible?.(parseBool$1(visible));
 	const touchable = specs.touchable ? readXmlAttr(source, specs.touchable) : void 0;
-	if (touchable !== void 0) object.setTouchable?.(parseBool(touchable));
+	if (touchable !== void 0) object.setTouchable?.(parseBool$1(touchable));
 	const grayed = specs.grayed ? readXmlAttr(source, specs.grayed) : void 0;
-	if (grayed !== void 0) object.setGrayed?.(parseBool(grayed));
+	if (grayed !== void 0) object.setGrayed?.(parseBool$1(grayed));
 	const tooltips = specs.tooltips ? readXmlAttr(source, specs.tooltips) : void 0;
 	if (tooltips !== void 0) object.setTooltips(tooltips);
 	const customData = specs.customData ? readXmlAttr(source, specs.customData) : void 0;
@@ -17138,16 +18835,16 @@ function createDisplayObject$1(ctx, doc, tagName, attrs, localControllers) {
 				g.setSize(w, h);
 			}
 			const imageLocked = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.image.attrs.locked);
-			if (imageLocked !== void 0) g.setLocked(parseBool(imageLocked));
+			if (imageLocked !== void 0) g.setLocked(parseBool$1(imageLocked));
 			const imageGroup = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.image.attrs.group);
 			if (imageGroup) g.setGroup(imageGroup);
 			const imageAspect = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.image.attrs.aspect);
-			if (imageAspect !== void 0) g.setAspect(parseBool(imageAspect));
+			if (imageAspect !== void 0) g.setAspect(parseBool$1(imageAspect));
 			const imagePivot = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.image.attrs.pivot);
 			if (imagePivot) {
 				const [pivotX, pivotY] = parseXYString(imagePivot);
 				const imageAnchor = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.image.attrs.anchor);
-				g.setPivot(pivotX, pivotY, parseBool(imageAnchor));
+				g.setPivot(pivotX, pivotY, parseBool$1(imageAnchor));
 			}
 			const imageScale = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.image.attrs.scale);
 			if (imageScale) {
@@ -17164,9 +18861,9 @@ function createDisplayObject$1(ctx, doc, tagName, attrs, localControllers) {
 			const imageAlpha = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.image.attrs.alpha);
 			if (imageAlpha !== void 0) g.setAlpha(parseFloat2(imageAlpha, 1));
 			const imageVisible = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.image.attrs.visible);
-			if (imageVisible !== void 0) g.setVisible(parseBool(imageVisible));
+			if (imageVisible !== void 0) g.setVisible(parseBool$1(imageVisible));
 			const imageGrayed = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.image.attrs.grayed);
-			if (imageGrayed !== void 0) g.setGrayed(parseBool(imageGrayed));
+			if (imageGrayed !== void 0) g.setGrayed(parseBool$1(imageGrayed));
 			const imageFileName = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.image.attrs.fileName);
 			if (imageFileName !== void 0) g.setFileName(imageFileName);
 			const imagePackageId = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.image.attrs.pkg);
@@ -17209,7 +18906,7 @@ function createDisplayObject$1(ctx, doc, tagName, attrs, localControllers) {
 			break;
 		}
 		case "text": {
-			const isInputText = parseBool(readXmlAttr(attrs, PROJECT_XML_PROTOCOL.text.attrs.input));
+			const isInputText = parseBool$1(readXmlAttr(attrs, PROJECT_XML_PROTOCOL.text.attrs.input));
 			const g = isInputText ? doc.createGTextInput(name) : doc.createGTextField(name);
 			const textXY = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.text.attrs.xy);
 			if (textXY) {
@@ -17225,7 +18922,7 @@ function createDisplayObject$1(ctx, doc, tagName, attrs, localControllers) {
 			if (textPivot) {
 				const [pivotX, pivotY] = parseXYString(textPivot);
 				const textAnchor = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.text.attrs.anchor);
-				g.setPivot(pivotX, pivotY, parseBool(textAnchor));
+				g.setPivot(pivotX, pivotY, parseBool$1(textAnchor));
 			}
 			const textRestrictSize = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.text.attrs.restrictSize);
 			if (textRestrictSize) {
@@ -17242,11 +18939,11 @@ function createDisplayObject$1(ctx, doc, tagName, attrs, localControllers) {
 			const textAlpha = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.text.attrs.alpha);
 			if (textAlpha !== void 0) g.setAlpha(parseFloat2(textAlpha, 1));
 			const textVisible = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.text.attrs.visible);
-			if (textVisible !== void 0) g.setVisible(parseBool(textVisible));
+			if (textVisible !== void 0) g.setVisible(parseBool$1(textVisible));
 			const textTouchable = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.text.attrs.touchable);
-			if (textTouchable !== void 0) g.setTouchable(parseBool(textTouchable));
+			if (textTouchable !== void 0) g.setTouchable(parseBool$1(textTouchable));
 			const textGrayed = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.text.attrs.grayed);
-			if (textGrayed !== void 0) g.setGrayed(parseBool(textGrayed));
+			if (textGrayed !== void 0) g.setGrayed(parseBool$1(textGrayed));
 			const textCustomData = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.text.attrs.customData);
 			if (textCustomData !== void 0) g.setCustomData(textCustomData);
 			const textValue = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.text.attrs.text);
@@ -17278,31 +18975,31 @@ function createDisplayObject$1(ctx, doc, tagName, attrs, localControllers) {
 				ellipsis: 4
 			}[textAutoSize] ?? 1);
 			const textSingleLine = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.text.attrs.singleLine);
-			if (textSingleLine !== void 0) g.setSingleLine(parseBool(textSingleLine));
+			if (textSingleLine !== void 0) g.setSingleLine(parseBool$1(textSingleLine));
 			const textAutoClearText = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.text.attrs.autoClearText);
-			if (textAutoClearText !== void 0) g.setAutoClearText?.(parseBool(textAutoClearText));
+			if (textAutoClearText !== void 0) g.setAutoClearText?.(parseBool$1(textAutoClearText));
 			const textDemoText = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.text.attrs.demoText);
 			if (textDemoText !== void 0) g.setDemoText?.(String(textDemoText));
 			const textVars = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.text.attrs.vars);
-			if (textVars !== void 0) g.setTemplateVarsEnabled?.(parseBool(textVars));
+			if (textVars !== void 0) g.setTemplateVarsEnabled?.(parseBool$1(textVars));
 			const textFaceDilate = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.text.attrs.faceDilate);
 			if (textFaceDilate !== void 0) g.setFaceDilate?.(parseFloat2(textFaceDilate));
 			const textUnderlaySoftness = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.text.attrs.underlaySoftness);
 			if (textUnderlaySoftness !== void 0) g.setUnderlaySoftness?.(parseFloat2(textUnderlaySoftness));
 			const textUbb = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.text.attrs.ubb);
-			if (textUbb !== void 0) g.setUbbEnabled(parseBool(textUbb));
+			if (textUbb !== void 0) g.setUbbEnabled(parseBool$1(textUbb));
 			const textLeading = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.text.attrs.leading);
 			if (textLeading !== void 0) g.setLeading?.(parseInt2(textLeading));
 			const textLetterSpacing = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.text.attrs.letterSpacing);
 			if (textLetterSpacing !== void 0) g.setLetterSpacing?.(parseInt2(textLetterSpacing));
 			const textUnderline = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.text.attrs.underline);
-			if (textUnderline !== void 0) g.setUnderline?.(parseBool(textUnderline));
+			if (textUnderline !== void 0) g.setUnderline?.(parseBool$1(textUnderline));
 			const textItalic = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.text.attrs.italic);
-			if (textItalic !== void 0) g.setItalic?.(parseBool(textItalic));
+			if (textItalic !== void 0) g.setItalic?.(parseBool$1(textItalic));
 			const textBold = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.text.attrs.bold);
-			if (textBold !== void 0) g.setBold?.(parseBool(textBold));
+			if (textBold !== void 0) g.setBold?.(parseBool$1(textBold));
 			const textStrikethrough = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.text.attrs.strikethrough);
-			if (textStrikethrough !== void 0) g.setStrikethrough?.(parseBool(textStrikethrough));
+			if (textStrikethrough !== void 0) g.setStrikethrough?.(parseBool$1(textStrikethrough));
 			const textStrokeColor = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.text.attrs.strokeColor);
 			if (textStrokeColor) {
 				g.setStrokeColor?.(textStrokeColor);
@@ -17328,7 +19025,7 @@ function createDisplayObject$1(ctx, doc, tagName, attrs, localControllers) {
 				const inputRestrict = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.textInput.attrs.restrict);
 				if (inputRestrict !== void 0) input.setRestrict(String(inputRestrict));
 				const inputPassword = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.textInput.attrs.password);
-				if (inputPassword !== void 0) input.setPassword(parseBool(inputPassword));
+				if (inputPassword !== void 0) input.setPassword(parseBool$1(inputPassword));
 				const inputKeyboardType = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.textInput.attrs.keyboardType);
 				if (inputKeyboardType !== void 0) input.setKeyboardType?.(parseInt2(inputKeyboardType));
 			}
@@ -17351,7 +19048,7 @@ function createDisplayObject$1(ctx, doc, tagName, attrs, localControllers) {
 			if (richTextPivot) {
 				const [pivotX, pivotY] = parseXYString(richTextPivot);
 				const richTextAnchor = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.richText.attrs.anchor);
-				g.setPivot(pivotX, pivotY, parseBool(richTextAnchor));
+				g.setPivot(pivotX, pivotY, parseBool$1(richTextAnchor));
 			}
 			const richTextRestrictSize = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.richText.attrs.restrictSize);
 			if (richTextRestrictSize) {
@@ -17368,11 +19065,11 @@ function createDisplayObject$1(ctx, doc, tagName, attrs, localControllers) {
 			const richTextAlpha = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.richText.attrs.alpha);
 			if (richTextAlpha !== void 0) g.setAlpha(parseFloat2(richTextAlpha, 1));
 			const richTextVisible = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.richText.attrs.visible);
-			if (richTextVisible !== void 0) g.setVisible(parseBool(richTextVisible));
+			if (richTextVisible !== void 0) g.setVisible(parseBool$1(richTextVisible));
 			const richTextTouchable = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.richText.attrs.touchable);
-			if (richTextTouchable !== void 0) g.setTouchable(parseBool(richTextTouchable));
+			if (richTextTouchable !== void 0) g.setTouchable(parseBool$1(richTextTouchable));
 			const richTextGrayed = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.richText.attrs.grayed);
-			if (richTextGrayed !== void 0) g.setGrayed(parseBool(richTextGrayed));
+			if (richTextGrayed !== void 0) g.setGrayed(parseBool$1(richTextGrayed));
 			const richText = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.text.attrs.text);
 			if (richText !== void 0) g.setText(String(richText));
 			const richTextFontSize = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.text.attrs.fontSize);
@@ -17398,7 +19095,7 @@ function createDisplayObject$1(ctx, doc, tagName, attrs, localControllers) {
 			const richTextLetterSpacing = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.text.attrs.letterSpacing);
 			if (richTextLetterSpacing !== void 0) g.setLetterSpacing?.(parseInt2(richTextLetterSpacing));
 			const richTextUbb = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.text.attrs.ubb);
-			if (richTextUbb !== void 0) g.setUbbEnabled?.(parseBool(richTextUbb));
+			if (richTextUbb !== void 0) g.setUbbEnabled?.(parseBool$1(richTextUbb));
 			const richTextAutoSize = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.text.attrs.autoSize);
 			if (richTextAutoSize) g.setAutoSize({
 				none: 0,
@@ -17408,19 +19105,19 @@ function createDisplayObject$1(ctx, doc, tagName, attrs, localControllers) {
 				ellipsis: 4
 			}[richTextAutoSize] ?? 1);
 			const richTextSingleLine = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.text.attrs.singleLine);
-			if (richTextSingleLine !== void 0) g.setSingleLine?.(parseBool(richTextSingleLine));
+			if (richTextSingleLine !== void 0) g.setSingleLine?.(parseBool$1(richTextSingleLine));
 			const richTextAutoClearText = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.text.attrs.autoClearText);
-			if (richTextAutoClearText !== void 0) g.setAutoClearText?.(parseBool(richTextAutoClearText));
+			if (richTextAutoClearText !== void 0) g.setAutoClearText?.(parseBool$1(richTextAutoClearText));
 			const richTextUnderlaySoftness = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.richText.attrs.underlaySoftness);
 			if (richTextUnderlaySoftness !== void 0) g.setUnderlaySoftness?.(parseFloat2(richTextUnderlaySoftness));
 			const richTextUnderline = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.text.attrs.underline);
-			if (richTextUnderline !== void 0) g.setUnderline?.(parseBool(richTextUnderline));
+			if (richTextUnderline !== void 0) g.setUnderline?.(parseBool$1(richTextUnderline));
 			const richTextItalic = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.text.attrs.italic);
-			if (richTextItalic !== void 0) g.setItalic?.(parseBool(richTextItalic));
+			if (richTextItalic !== void 0) g.setItalic?.(parseBool$1(richTextItalic));
 			const richTextBold = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.text.attrs.bold);
-			if (richTextBold !== void 0) g.setBold?.(parseBool(richTextBold));
+			if (richTextBold !== void 0) g.setBold?.(parseBool$1(richTextBold));
 			const richTextStrikethrough = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.text.attrs.strikethrough);
-			if (richTextStrikethrough !== void 0) g.setStrikethrough?.(parseBool(richTextStrikethrough));
+			if (richTextStrikethrough !== void 0) g.setStrikethrough?.(parseBool$1(richTextStrikethrough));
 			const richTextStrokeColor = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.text.attrs.strokeColor);
 			if (richTextStrokeColor) {
 				g.setStrokeColor?.(richTextStrokeColor);
@@ -17456,7 +19153,7 @@ function createDisplayObject$1(ctx, doc, tagName, attrs, localControllers) {
 			if (inputPivot) {
 				const [pivotX, pivotY] = parseXYString(inputPivot);
 				const inputAnchor = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.textInput.attrs.anchor);
-				g.setPivot(pivotX, pivotY, parseBool(inputAnchor));
+				g.setPivot(pivotX, pivotY, parseBool$1(inputAnchor));
 			}
 			const inputRestrictSize = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.text.attrs.restrictSize);
 			if (inputRestrictSize) {
@@ -17473,11 +19170,11 @@ function createDisplayObject$1(ctx, doc, tagName, attrs, localControllers) {
 			const inputAlpha = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.textInput.attrs.alpha);
 			if (inputAlpha !== void 0) g.setAlpha(parseFloat2(inputAlpha, 1));
 			const inputVisible = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.textInput.attrs.visible);
-			if (inputVisible !== void 0) g.setVisible(parseBool(inputVisible));
+			if (inputVisible !== void 0) g.setVisible(parseBool$1(inputVisible));
 			const inputTouchable = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.textInput.attrs.touchable);
-			if (inputTouchable !== void 0) g.setTouchable(parseBool(inputTouchable));
+			if (inputTouchable !== void 0) g.setTouchable(parseBool$1(inputTouchable));
 			const inputGrayed = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.textInput.attrs.grayed);
-			if (inputGrayed !== void 0) g.setGrayed(parseBool(inputGrayed));
+			if (inputGrayed !== void 0) g.setGrayed(parseBool$1(inputGrayed));
 			const inputText = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.text.attrs.text);
 			if (inputText !== void 0) g.setText(String(inputText));
 			const inputFontSize = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.text.attrs.fontSize);
@@ -17511,27 +19208,27 @@ function createDisplayObject$1(ctx, doc, tagName, attrs, localControllers) {
 				ellipsis: 4
 			}[inputAutoSize] ?? 1);
 			const inputSingleLine = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.text.attrs.singleLine);
-			if (inputSingleLine !== void 0) g.setSingleLine?.(parseBool(inputSingleLine));
+			if (inputSingleLine !== void 0) g.setSingleLine?.(parseBool$1(inputSingleLine));
 			const inputAutoClearText = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.text.attrs.autoClearText);
-			if (inputAutoClearText !== void 0) g.setAutoClearText?.(parseBool(inputAutoClearText));
+			if (inputAutoClearText !== void 0) g.setAutoClearText?.(parseBool$1(inputAutoClearText));
 			const inputDemoText = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.text.attrs.demoText);
 			if (inputDemoText !== void 0) g.setDemoText?.(String(inputDemoText));
 			const inputVars = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.text.attrs.vars);
-			if (inputVars !== void 0) g.setTemplateVarsEnabled?.(parseBool(inputVars));
+			if (inputVars !== void 0) g.setTemplateVarsEnabled?.(parseBool$1(inputVars));
 			const inputFaceDilate = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.text.attrs.faceDilate);
 			if (inputFaceDilate !== void 0) g.setFaceDilate?.(parseFloat2(inputFaceDilate));
 			const inputUnderlaySoftness = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.text.attrs.underlaySoftness);
 			if (inputUnderlaySoftness !== void 0) g.setUnderlaySoftness?.(parseFloat2(inputUnderlaySoftness));
 			const inputUbb = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.text.attrs.ubb);
-			if (inputUbb !== void 0) g.setUbbEnabled?.(parseBool(inputUbb));
+			if (inputUbb !== void 0) g.setUbbEnabled?.(parseBool$1(inputUbb));
 			const inputUnderline = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.text.attrs.underline);
-			if (inputUnderline !== void 0) g.setUnderline?.(parseBool(inputUnderline));
+			if (inputUnderline !== void 0) g.setUnderline?.(parseBool$1(inputUnderline));
 			const inputItalic = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.text.attrs.italic);
-			if (inputItalic !== void 0) g.setItalic?.(parseBool(inputItalic));
+			if (inputItalic !== void 0) g.setItalic?.(parseBool$1(inputItalic));
 			const inputBold = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.text.attrs.bold);
-			if (inputBold !== void 0) g.setBold?.(parseBool(inputBold));
+			if (inputBold !== void 0) g.setBold?.(parseBool$1(inputBold));
 			const inputStrikethrough = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.text.attrs.strikethrough);
-			if (inputStrikethrough !== void 0) g.setStrikethrough?.(parseBool(inputStrikethrough));
+			if (inputStrikethrough !== void 0) g.setStrikethrough?.(parseBool$1(inputStrikethrough));
 			const inputStrokeColor = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.text.attrs.strokeColor);
 			if (inputStrokeColor) {
 				g.setStrokeColor?.(inputStrokeColor);
@@ -17555,7 +19252,7 @@ function createDisplayObject$1(ctx, doc, tagName, attrs, localControllers) {
 			const inputRestrict = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.textInput.attrs.restrict);
 			if (inputRestrict !== void 0) g.setRestrict(inputRestrict);
 			const inputPassword = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.textInput.attrs.password);
-			if (inputPassword !== void 0) g.setPassword(parseBool(inputPassword));
+			if (inputPassword !== void 0) g.setPassword(parseBool$1(inputPassword));
 			const inputKeyboardType = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.textInput.attrs.keyboardType);
 			if (inputKeyboardType !== void 0) g.setKeyboardType?.(parseInt2(inputKeyboardType));
 			obj = g;
@@ -17574,7 +19271,7 @@ function createDisplayObject$1(ctx, doc, tagName, attrs, localControllers) {
 				g.setSize(w, h);
 			}
 			const graphLocked = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.graph.attrs.locked);
-			if (graphLocked !== void 0) g.setLocked(parseBool(graphLocked));
+			if (graphLocked !== void 0) g.setLocked(parseBool$1(graphLocked));
 			const graphRestrictSize = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.graph.attrs.restrictSize);
 			if (graphRestrictSize) {
 				const parts = graphRestrictSize.split(",").map(Number);
@@ -17589,16 +19286,16 @@ function createDisplayObject$1(ctx, doc, tagName, attrs, localControllers) {
 			if (graphPivot) {
 				const [pivotX, pivotY] = parseXYString(graphPivot);
 				const graphAnchor = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.graph.attrs.anchor);
-				g.setPivot(pivotX, pivotY, parseBool(graphAnchor));
+				g.setPivot(pivotX, pivotY, parseBool$1(graphAnchor));
 			}
 			const graphRotation = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.graph.attrs.rotation);
 			if (graphRotation !== void 0) g.setRotation(parseFloat2(graphRotation));
 			const graphAlpha = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.graph.attrs.alpha);
 			if (graphAlpha !== void 0) g.setAlpha(parseFloat2(graphAlpha, 1));
 			const graphVisible = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.graph.attrs.visible);
-			if (graphVisible !== void 0) g.setVisible(parseBool(graphVisible));
+			if (graphVisible !== void 0) g.setVisible(parseBool$1(graphVisible));
 			const graphTouchable = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.graph.attrs.touchable);
-			if (graphTouchable !== void 0) g.setTouchable(parseBool(graphTouchable));
+			if (graphTouchable !== void 0) g.setTouchable(parseBool$1(graphTouchable));
 			const graphSkew = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.graph.attrs.skew);
 			if (graphSkew) {
 				const [skewX, skewY] = parseXYString(graphSkew);
@@ -17655,17 +19352,17 @@ function createDisplayObject$1(ctx, doc, tagName, attrs, localControllers) {
 				g.setSize(w, h);
 			}
 			const groupLocked = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.group.attrs.locked);
-			if (groupLocked !== void 0) g.setLocked(parseBool(groupLocked));
+			if (groupLocked !== void 0) g.setLocked(parseBool$1(groupLocked));
 			const groupPivot = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.group.attrs.pivot);
 			if (groupPivot) {
 				const [pivotX, pivotY] = parseXYString(groupPivot);
 				const groupAnchor = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.group.attrs.anchor);
-				g.setPivot(pivotX, pivotY, parseBool(groupAnchor));
+				g.setPivot(pivotX, pivotY, parseBool$1(groupAnchor));
 			}
 			const groupRef = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.group.attrs.group);
 			if (groupRef) g.setGroup(groupRef);
 			const groupVisible = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.group.attrs.visible);
-			if (groupVisible !== void 0) g.setVisible(parseBool(groupVisible));
+			if (groupVisible !== void 0) g.setVisible(parseBool$1(groupVisible));
 			const groupLayout = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.group.attrs.layout);
 			if (groupLayout) g.setLayout({
 				none: 0,
@@ -17677,11 +19374,11 @@ function createDisplayObject$1(ctx, doc, tagName, attrs, localControllers) {
 			const columnGap = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.group.attrs.columnGap);
 			if (columnGap !== void 0) g.setColumnGap(parseInt2(columnGap));
 			const groupAdvanced = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.group.attrs.advanced);
-			if (groupAdvanced !== void 0) g.setAdvanced(parseBool(groupAdvanced));
+			if (groupAdvanced !== void 0) g.setAdvanced(parseBool$1(groupAdvanced));
 			const excludeInvisibles = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.group.attrs.excludeInvisibles);
-			if (excludeInvisibles !== void 0) g.setExcludeInvisibles?.(parseBool(excludeInvisibles));
+			if (excludeInvisibles !== void 0) g.setExcludeInvisibles?.(parseBool$1(excludeInvisibles));
 			const autoSizeDisabled = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.group.attrs.autoSizeDisabled);
-			if (autoSizeDisabled !== void 0) g.setAutoSizeDisabled?.(parseBool(autoSizeDisabled));
+			if (autoSizeDisabled !== void 0) g.setAutoSizeDisabled?.(parseBool$1(autoSizeDisabled));
 			const mainGridIndex = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.group.attrs.mainGridIndex);
 			if (mainGridIndex !== void 0) g.setMainGridIndex?.(parseInt2(mainGridIndex));
 			obj = g;
@@ -17703,7 +19400,7 @@ function createDisplayObject$1(ctx, doc, tagName, attrs, localControllers) {
 			if (loaderPivot) {
 				const [pivotX, pivotY] = parseXYString(loaderPivot);
 				const loaderAnchor = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.loader.attrs.anchor);
-				g.setPivot(pivotX, pivotY, parseBool(loaderAnchor));
+				g.setPivot(pivotX, pivotY, parseBool$1(loaderAnchor));
 			}
 			const loaderScale = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.loader.attrs.scale);
 			if (loaderScale) {
@@ -17711,9 +19408,9 @@ function createDisplayObject$1(ctx, doc, tagName, attrs, localControllers) {
 				g.setScale(scaleX, scaleY);
 			}
 			const loaderGrayed = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.loader.attrs.grayed);
-			if (loaderGrayed !== void 0) g.setGrayed(parseBool(loaderGrayed));
+			if (loaderGrayed !== void 0) g.setGrayed(parseBool$1(loaderGrayed));
 			const loaderVisible = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.loader.attrs.visible);
-			if (loaderVisible !== void 0) g.setVisible(parseBool(loaderVisible));
+			if (loaderVisible !== void 0) g.setVisible(parseBool$1(loaderVisible));
 			const loaderUrl = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.loader.attrs.url);
 			if (loaderUrl) g.setUrl(loaderUrl);
 			const loaderAlign = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.loader.attrs.align);
@@ -17738,13 +19435,13 @@ function createDisplayObject$1(ctx, doc, tagName, attrs, localControllers) {
 				scaleNoBorder: 5
 			}[loaderFill] ?? 0);
 			const loaderShrinkOnly = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.loader.attrs.shrinkOnly);
-			if (loaderShrinkOnly !== void 0) g.setShrinkOnly?.(parseBool(loaderShrinkOnly));
+			if (loaderShrinkOnly !== void 0) g.setShrinkOnly?.(parseBool$1(loaderShrinkOnly));
 			const loaderAutoSize = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.loader.attrs.autoSize);
-			if (loaderAutoSize !== void 0) g.setAutoSize?.(parseBool(loaderAutoSize));
+			if (loaderAutoSize !== void 0) g.setAutoSize?.(parseBool$1(loaderAutoSize));
 			const useResize = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.loader.attrs.useResize);
-			if (useResize !== void 0) g.setUseResize?.(parseBool(useResize));
+			if (useResize !== void 0) g.setUseResize?.(parseBool$1(useResize));
 			const clearOnPublish = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.loader.attrs.clearOnPublish);
-			if (clearOnPublish !== void 0) g.setClearOnPublish?.(parseBool(clearOnPublish));
+			if (clearOnPublish !== void 0) g.setClearOnPublish?.(parseBool$1(clearOnPublish));
 			const loaderColor = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.loader.attrs.color);
 			if (loaderColor) g.setColor(loaderColor);
 			const loaderFilter = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.loader.attrs.filter);
@@ -17752,7 +19449,7 @@ function createDisplayObject$1(ctx, doc, tagName, attrs, localControllers) {
 			const loaderFilterData = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.loader.attrs.filterData);
 			if (loaderFilterData !== void 0) g.setFilterData(loaderFilterData);
 			const loaderPlaying = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.loader.attrs.playing);
-			if (loaderPlaying !== void 0) g.setPlaying?.(parseBool(loaderPlaying));
+			if (loaderPlaying !== void 0) g.setPlaying?.(parseBool$1(loaderPlaying));
 			const loaderFrame = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.loader.attrs.frame);
 			if (loaderFrame !== void 0) g.setFrame?.(parseInt2(loaderFrame));
 			const fillMethod = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.loader.attrs.fillMethod);
@@ -17791,10 +19488,10 @@ function createDisplayObject$1(ctx, doc, tagName, attrs, localControllers) {
 			if (loader3dPivot) {
 				const [pivotX, pivotY] = parseXYString(loader3dPivot);
 				const loader3dAnchor = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.loader3D.attrs.anchor);
-				g.setPivot(pivotX, pivotY, parseBool(loader3dAnchor));
+				g.setPivot(pivotX, pivotY, parseBool$1(loader3dAnchor));
 			}
 			const loader3dVisible = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.loader3D.attrs.visible);
-			if (loader3dVisible !== void 0) g.setVisible(parseBool(loader3dVisible));
+			if (loader3dVisible !== void 0) g.setVisible(parseBool$1(loader3dVisible));
 			const loader3dUrl = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.loader3D.attrs.url);
 			if (loader3dUrl) g.setUrl(loader3dUrl);
 			const loader3dAlign = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.loader3D.attrs.align);
@@ -17819,23 +19516,23 @@ function createDisplayObject$1(ctx, doc, tagName, attrs, localControllers) {
 				scaleNoBorder: 5
 			}[loader3dFill] ?? 0);
 			const loader3dShrinkOnly = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.loader3D.attrs.shrinkOnly);
-			if (loader3dShrinkOnly !== void 0) g.setShrinkOnly?.(parseBool(loader3dShrinkOnly));
+			if (loader3dShrinkOnly !== void 0) g.setShrinkOnly?.(parseBool$1(loader3dShrinkOnly));
 			const loader3dAutoSize = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.loader3D.attrs.autoSize);
-			if (loader3dAutoSize !== void 0) g.setAutoSize?.(parseBool(loader3dAutoSize));
+			if (loader3dAutoSize !== void 0) g.setAutoSize?.(parseBool$1(loader3dAutoSize));
 			const animation = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.loader3D.attrs.animation);
 			if (animation !== void 0) g.setAnimationName?.(String(animation));
 			const skinName = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.loader3D.attrs.skinName);
 			if (skinName !== void 0) g.setSkinName?.(String(skinName));
 			const playing = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.loader3D.attrs.playing);
-			if (playing !== void 0) g.setPlaying?.(parseBool(playing));
+			if (playing !== void 0) g.setPlaying?.(parseBool$1(playing));
 			const frame = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.loader3D.attrs.frame);
 			if (frame !== void 0) g.setFrame?.(parseInt2(frame));
 			const loop = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.loader3D.attrs.loop);
-			if (loop !== void 0) g.setLoop?.(parseBool(loop));
+			if (loop !== void 0) g.setLoop?.(parseBool$1(loop));
 			const loader3dColor = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.loader3D.attrs.color);
 			if (loader3dColor) g.setColor(loader3dColor);
 			const clearOnPublish = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.loader3D.attrs.clearOnPublish);
-			if (clearOnPublish !== void 0) g.setClearOnPublish(parseBool(clearOnPublish));
+			if (clearOnPublish !== void 0) g.setClearOnPublish(parseBool$1(clearOnPublish));
 			obj = g;
 			break;
 		}
@@ -17860,16 +19557,16 @@ function createDisplayObject$1(ctx, doc, tagName, attrs, localControllers) {
 			if (movieClipPivot) {
 				const [pivotX, pivotY] = parseXYString(movieClipPivot);
 				const movieClipAnchor = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.movieClip.attrs.anchor);
-				g.setPivot(pivotX, pivotY, parseBool(movieClipAnchor));
+				g.setPivot(pivotX, pivotY, parseBool$1(movieClipAnchor));
 			}
 			const movieClipRotation = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.movieClip.attrs.rotation);
 			if (movieClipRotation !== void 0) g.setRotation(parseFloat2(movieClipRotation));
 			const movieClipAlpha = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.movieClip.attrs.alpha);
 			if (movieClipAlpha !== void 0) g.setAlpha(parseFloat2(movieClipAlpha, 1));
 			const movieClipVisible = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.movieClip.attrs.visible);
-			if (movieClipVisible !== void 0) g.setVisible(parseBool(movieClipVisible));
+			if (movieClipVisible !== void 0) g.setVisible(parseBool$1(movieClipVisible));
 			const movieClipGrayed = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.movieClip.attrs.grayed);
-			if (movieClipGrayed !== void 0) g.setGrayed(parseBool(movieClipGrayed));
+			if (movieClipGrayed !== void 0) g.setGrayed(parseBool$1(movieClipGrayed));
 			const movieClipFileName = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.movieClip.attrs.fileName);
 			if (movieClipFileName !== void 0) g.setFileName(movieClipFileName);
 			const movieClipPackageId = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.movieClip.attrs.pkg);
@@ -17879,7 +19576,7 @@ function createDisplayObject$1(ctx, doc, tagName, attrs, localControllers) {
 			const movieClipFilterData = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.movieClip.attrs.filterData);
 			if (movieClipFilterData !== void 0) g.setFilterData(movieClipFilterData);
 			const playing = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.movieClip.attrs.playing);
-			if (playing !== void 0) g.setPlaying(parseBool(playing));
+			if (playing !== void 0) g.setPlaying(parseBool$1(playing));
 			const frame = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.movieClip.attrs.frame);
 			if (frame !== void 0) g.setFrame(parseInt2(frame));
 			const movieClipColor = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.movieClip.attrs.color);
@@ -17902,7 +19599,7 @@ function createDisplayObject$1(ctx, doc, tagName, attrs, localControllers) {
 				g.setSize(w, h);
 			}
 			const componentLocked = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.componentInstance.attrs.locked);
-			if (componentLocked !== void 0) g.setLocked(parseBool(componentLocked));
+			if (componentLocked !== void 0) g.setLocked(parseBool$1(componentLocked));
 			const componentRestrictSize = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.componentInstance.attrs.restrictSize);
 			if (componentRestrictSize) {
 				const parts = componentRestrictSize.split(",").map(Number);
@@ -17914,12 +19611,12 @@ function createDisplayObject$1(ctx, doc, tagName, attrs, localControllers) {
 			const componentGroup = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.componentInstance.attrs.group);
 			if (componentGroup) g.setGroup(componentGroup);
 			const componentAspect = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.componentInstance.attrs.aspect);
-			if (componentAspect !== void 0) g.setAspect(parseBool(componentAspect));
+			if (componentAspect !== void 0) g.setAspect(parseBool$1(componentAspect));
 			const componentPivot = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.componentInstance.attrs.pivot);
 			if (componentPivot) {
 				const [pivotX, pivotY] = parseXYString(componentPivot);
 				const componentAnchor = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.componentInstance.attrs.anchor);
-				g.setPivot(pivotX, pivotY, parseBool(componentAnchor));
+				g.setPivot(pivotX, pivotY, parseBool$1(componentAnchor));
 			}
 			const componentScale = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.componentInstance.attrs.scale);
 			if (componentScale) {
@@ -17931,11 +19628,11 @@ function createDisplayObject$1(ctx, doc, tagName, attrs, localControllers) {
 			const componentAlpha = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.componentInstance.attrs.alpha);
 			if (componentAlpha !== void 0) g.setAlpha(parseFloat2(componentAlpha, 1));
 			const componentVisible = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.componentInstance.attrs.visible);
-			if (componentVisible !== void 0) g.setVisible(parseBool(componentVisible));
+			if (componentVisible !== void 0) g.setVisible(parseBool$1(componentVisible));
 			const componentTouchable = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.componentInstance.attrs.touchable);
-			if (componentTouchable !== void 0) g.setTouchable(parseBool(componentTouchable));
+			if (componentTouchable !== void 0) g.setTouchable(parseBool$1(componentTouchable));
 			const componentGrayed = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.componentInstance.attrs.grayed);
-			if (componentGrayed !== void 0) g.setGrayed(parseBool(componentGrayed));
+			if (componentGrayed !== void 0) g.setGrayed(parseBool$1(componentGrayed));
 			const componentTooltips = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.componentInstance.attrs.tooltips);
 			if (componentTooltips !== void 0) g.setTooltips(componentTooltips);
 			const componentCustomData = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.componentInstance.attrs.customData);
@@ -17957,7 +19654,7 @@ function createDisplayObject$1(ctx, doc, tagName, attrs, localControllers) {
 		}
 		case "list": {
 			const treeView = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.list.attrs.treeView);
-			const isTree = treeView !== void 0 && parseBool(treeView);
+			const isTree = treeView !== void 0 && parseBool$1(treeView);
 			let g;
 			if (isTree) {
 				g = doc.createGTree(name).setTreeView(true);
@@ -17982,14 +19679,14 @@ function createDisplayObject$1(ctx, doc, tagName, attrs, localControllers) {
 			if (listPivot) {
 				const [pivotX, pivotY] = parseXYString(listPivot);
 				const listAnchor = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.list.attrs.anchor);
-				g.setPivot(pivotX, pivotY, parseBool(listAnchor));
+				g.setPivot(pivotX, pivotY, parseBool$1(listAnchor));
 			}
 			const listGroup = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.list.attrs.group);
 			if (listGroup) g.setGroup(listGroup);
 			const listVisible = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.list.attrs.visible);
-			if (listVisible !== void 0) g.setVisible(parseBool(listVisible));
+			if (listVisible !== void 0) g.setVisible(parseBool$1(listVisible));
 			const listTouchable = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.list.attrs.touchable);
-			if (listTouchable !== void 0) g.setTouchable(parseBool(listTouchable));
+			if (listTouchable !== void 0) g.setTouchable(parseBool$1(listTouchable));
 			const defaultItem = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.list.attrs.defaultItem);
 			if (defaultItem) g.setDefaultItem(defaultItem);
 			const scrollBarRes = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.list.attrs.scrollBarRes);
@@ -18048,7 +19745,7 @@ function createDisplayObject$1(ctx, doc, tagName, attrs, localControllers) {
 				if (resolvedLayout === 4 && lineItemCount2 !== void 0) g.setLineCount?.(parseInt2(lineItemCount2));
 			}
 			const autoResizeItem = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.list.attrs.autoResizeItem);
-			if (autoResizeItem !== void 0) g.setAutoResizeItem?.(parseBool(autoResizeItem));
+			if (autoResizeItem !== void 0) g.setAutoResizeItem?.(parseBool$1(autoResizeItem));
 			const childrenRenderOrder = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.list.attrs.childrenRenderOrder);
 			if (childrenRenderOrder) g.setChildrenRenderOrder?.({
 				ascent: 0,
@@ -18111,11 +19808,11 @@ function createDisplayObject$1(ctx, doc, tagName, attrs, localControllers) {
 				});
 			}
 			const scrollItemToViewOnClick = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.list.attrs.scrollItemToViewOnClick);
-			if (scrollItemToViewOnClick !== void 0) g.setScrollItemToViewOnClick?.(parseBool(scrollItemToViewOnClick));
+			if (scrollItemToViewOnClick !== void 0) g.setScrollItemToViewOnClick?.(parseBool$1(scrollItemToViewOnClick));
 			const foldInvisibleItems = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.list.attrs.foldInvisibleItems);
-			if (foldInvisibleItems !== void 0) g.setFoldInvisibleItems?.(parseBool(foldInvisibleItems));
+			if (foldInvisibleItems !== void 0) g.setFoldInvisibleItems?.(parseBool$1(foldInvisibleItems));
 			const autoClearItems = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.list.attrs.autoClearItems);
-			if (autoClearItems !== void 0) g.setAutoClearItems?.(parseBool(autoClearItems));
+			if (autoClearItems !== void 0) g.setAutoClearItems?.(parseBool$1(autoClearItems));
 			const listItemChildName = getProtocolChildName$2(PROJECT_XML_PROTOCOL.list, "item");
 			const items = listItemChildName ? ensureArray(attrs[listItemChildName]) : [];
 			if (items.length > 0) {
@@ -18180,7 +19877,7 @@ function createDisplayObject$1(ctx, doc, tagName, attrs, localControllers) {
 			const page = extSpecs.page ? readXmlAttr(extAttrs, extSpecs.page) : void 0;
 			if (page !== void 0) componentObj.setInstancePage?.(page);
 			const checked = extSpecs.checked ? readXmlAttr(extAttrs, extSpecs.checked) : void 0;
-			if (checked !== void 0) componentObj.setInstanceChecked?.(parseBool(checked));
+			if (checked !== void 0) componentObj.setInstanceChecked?.(parseBool$1(checked));
 			const sound = extSpecs.sound ? readXmlAttr(extAttrs, extSpecs.sound) : void 0;
 			if (sound !== void 0) componentObj.setInstanceSound?.(sound);
 			const soundVolumeScale = extSpecs.soundVolumeScale ? readXmlAttr(extAttrs, extSpecs.soundVolumeScale) : void 0;
@@ -18192,7 +19889,7 @@ function createDisplayObject$1(ctx, doc, tagName, attrs, localControllers) {
 			const visibleItemCount = extSpecs.visibleItemCount ? readXmlAttr(extAttrs, extSpecs.visibleItemCount) : void 0;
 			if (visibleItemCount !== void 0) componentObj.setInstanceVisibleItemCount?.(parseInt2(visibleItemCount));
 			const autoClearItems = extSpecs.autoClearItems ? readXmlAttr(extAttrs, extSpecs.autoClearItems) : void 0;
-			if (autoClearItems !== void 0) componentObj.setInstanceAutoClearItems?.(parseBool(autoClearItems));
+			if (autoClearItems !== void 0) componentObj.setInstanceAutoClearItems?.(parseBool$1(autoClearItems));
 			const value = extSpecs.value ? readXmlAttr(extAttrs, extSpecs.value) : void 0;
 			if (value !== void 0) componentObj.setInstanceValue?.(parseInt2(value));
 			const max = extSpecs.max ? readXmlAttr(extAttrs, extSpecs.max) : void 0;
@@ -18214,9 +19911,9 @@ function parseGear(_ctx, doc, obj, gearTag, attrs, localControllers) {
 	const gear = doc.createGear();
 	gear.setGearType(gearType);
 	const tween = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.gear.attrs.tween);
-	gear.setTween(parseBool(tween));
+	gear.setTween(parseBool$1(tween));
 	const positionsInPercent = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.gear.attrs.positionsInPercent);
-	if (positionsInPercent !== void 0) gear.setPositionsInPercent(parseBool(positionsInPercent));
+	if (positionsInPercent !== void 0) gear.setPositionsInPercent(parseBool$1(positionsInPercent));
 	const ctrlName = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.gear.attrs.controller) || "";
 	const controller = localControllers.get(ctrlName) || null;
 	if (controller) gear.setController(controller);
@@ -18440,7 +20137,7 @@ function readComponentXml(ctx, comp, xmlContent) {
 		comp.setPivotX?.(parseFloat(parts[0]) || 0);
 		comp.setPivotY?.(parseFloat(parts[1]) || 0);
 		const anchor = readXmlAttr(compNode, PROJECT_XML_PROTOCOL.componentRoot.attrs.anchor);
-		if (anchor !== void 0) comp.setPivotAsAnchor?.(parseBool(anchor));
+		if (anchor !== void 0) comp.setPivotAsAnchor?.(parseBool$1(anchor));
 	}
 	const margin = readXmlAttr(compNode, PROJECT_XML_PROTOCOL.componentRoot.attrs.margin);
 	if (margin) {
@@ -18463,7 +20160,7 @@ function readComponentXml(ctx, comp, xmlContent) {
 	const bgColor = readXmlAttr(compNode, PROJECT_XML_PROTOCOL.componentRoot.attrs.bgColor);
 	if (bgColor !== void 0) comp.setBgColor?.(bgColor);
 	const bgColorEnabled = readXmlAttr(compNode, PROJECT_XML_PROTOCOL.componentRoot.attrs.bgColorEnabled);
-	if (bgColorEnabled !== void 0) comp.setBgColorEnabled?.(parseBool(bgColorEnabled));
+	if (bgColorEnabled !== void 0) comp.setBgColorEnabled?.(parseBool$1(bgColorEnabled));
 	const designImageAlpha = readXmlAttr(compNode, PROJECT_XML_PROTOCOL.componentRoot.attrs.designImageAlpha);
 	if (designImageAlpha !== void 0) comp.setDesignImageAlpha?.(parseInt2(designImageAlpha));
 	const designImageLayer = readXmlAttr(compNode, PROJECT_XML_PROTOCOL.componentRoot.attrs.designImageLayer);
@@ -18487,11 +20184,11 @@ function readComponentXml(ctx, comp, xmlContent) {
 		});
 	}
 	const opaque = readXmlAttr(compNode, PROJECT_XML_PROTOCOL.componentRoot.attrs.opaque);
-	if (opaque !== void 0) comp.setOpaque?.(parseBool(opaque));
+	if (opaque !== void 0) comp.setOpaque?.(parseBool$1(opaque));
 	const mask = readXmlAttr(compNode, PROJECT_XML_PROTOCOL.componentRoot.attrs.mask);
 	if (mask !== void 0) comp.setMask?.(mask);
 	const reversedMask = readXmlAttr(compNode, PROJECT_XML_PROTOCOL.componentRoot.attrs.reversedMask);
-	if (reversedMask !== void 0) comp.setReversedMask?.(parseBool(reversedMask));
+	if (reversedMask !== void 0) comp.setReversedMask?.(parseBool$1(reversedMask));
 	const hitTest = readXmlAttr(compNode, PROJECT_XML_PROTOCOL.componentRoot.attrs.hitTest);
 	if (hitTest !== void 0) comp.setHitTest?.(hitTest);
 	const customData = readXmlAttr(compNode, PROJECT_XML_PROTOCOL.componentRoot.attrs.customData);
@@ -18554,23 +20251,23 @@ function readComponentXml(ctx, comp, xmlContent) {
 					case "ComboBox":
 						if (readXmlAttr(extAttrs, EXTENSION_PROTOCOL_MAP$1.ComboBox.attrs.dropdown) !== void 0) comp.setDropdown?.(String(readXmlAttr(extAttrs, EXTENSION_PROTOCOL_MAP$1.ComboBox.attrs.dropdown)));
 						if (readXmlAttr(extAttrs, EXTENSION_PROTOCOL_MAP$1.ComboBox.attrs.selectionController) !== void 0) comp.setSelectionController?.(String(readXmlAttr(extAttrs, EXTENSION_PROTOCOL_MAP$1.ComboBox.attrs.selectionController)));
-						if (readXmlAttr(extAttrs, EXTENSION_PROTOCOL_MAP$1.ComboBox.attrs.autoClearItems) !== void 0) comp.setAutoClearItems?.(parseBool(readXmlAttr(extAttrs, EXTENSION_PROTOCOL_MAP$1.ComboBox.attrs.autoClearItems)));
+						if (readXmlAttr(extAttrs, EXTENSION_PROTOCOL_MAP$1.ComboBox.attrs.autoClearItems) !== void 0) comp.setAutoClearItems?.(parseBool$1(readXmlAttr(extAttrs, EXTENSION_PROTOCOL_MAP$1.ComboBox.attrs.autoClearItems)));
 						break;
 					case "Label":
 						if (readXmlAttr(extAttrs, EXTENSION_PROTOCOL_MAP$1.Label.attrs.prompt) !== void 0) comp.setPromptText?.(String(readXmlAttr(extAttrs, EXTENSION_PROTOCOL_MAP$1.Label.attrs.prompt)));
 						break;
 					case "ProgressBar":
 						if (readXmlAttr(extAttrs, EXTENSION_PROTOCOL_MAP$1.ProgressBar.attrs.titleType) !== void 0) comp.setTitleType?.(parseTitleType(readXmlAttr(extAttrs, EXTENSION_PROTOCOL_MAP$1.ProgressBar.attrs.titleType)));
-						if (readXmlAttr(extAttrs, EXTENSION_PROTOCOL_MAP$1.ProgressBar.attrs.reverse) !== void 0) comp.setReverse?.(parseBool(readXmlAttr(extAttrs, EXTENSION_PROTOCOL_MAP$1.ProgressBar.attrs.reverse)));
+						if (readXmlAttr(extAttrs, EXTENSION_PROTOCOL_MAP$1.ProgressBar.attrs.reverse) !== void 0) comp.setReverse?.(parseBool$1(readXmlAttr(extAttrs, EXTENSION_PROTOCOL_MAP$1.ProgressBar.attrs.reverse)));
 						break;
 					case "Slider":
 						if (readXmlAttr(extAttrs, EXTENSION_PROTOCOL_MAP$1.Slider.attrs.titleType) !== void 0) comp.setTitleType?.(parseTitleType(readXmlAttr(extAttrs, EXTENSION_PROTOCOL_MAP$1.Slider.attrs.titleType)));
-						if (readXmlAttr(extAttrs, EXTENSION_PROTOCOL_MAP$1.Slider.attrs.reverse) !== void 0) comp.setReverse?.(parseBool(readXmlAttr(extAttrs, EXTENSION_PROTOCOL_MAP$1.Slider.attrs.reverse)));
-						if (readXmlAttr(extAttrs, EXTENSION_PROTOCOL_MAP$1.Slider.attrs.wholeNumbers) !== void 0) comp.setWholeNumbers?.(parseBool(readXmlAttr(extAttrs, EXTENSION_PROTOCOL_MAP$1.Slider.attrs.wholeNumbers)));
-						if (readXmlAttr(extAttrs, EXTENSION_PROTOCOL_MAP$1.Slider.attrs.changeOnClick) !== void 0) comp.setChangeOnClick?.(parseBool(readXmlAttr(extAttrs, EXTENSION_PROTOCOL_MAP$1.Slider.attrs.changeOnClick)));
+						if (readXmlAttr(extAttrs, EXTENSION_PROTOCOL_MAP$1.Slider.attrs.reverse) !== void 0) comp.setReverse?.(parseBool$1(readXmlAttr(extAttrs, EXTENSION_PROTOCOL_MAP$1.Slider.attrs.reverse)));
+						if (readXmlAttr(extAttrs, EXTENSION_PROTOCOL_MAP$1.Slider.attrs.wholeNumbers) !== void 0) comp.setWholeNumbers?.(parseBool$1(readXmlAttr(extAttrs, EXTENSION_PROTOCOL_MAP$1.Slider.attrs.wholeNumbers)));
+						if (readXmlAttr(extAttrs, EXTENSION_PROTOCOL_MAP$1.Slider.attrs.changeOnClick) !== void 0) comp.setChangeOnClick?.(parseBool$1(readXmlAttr(extAttrs, EXTENSION_PROTOCOL_MAP$1.Slider.attrs.changeOnClick)));
 						break;
 					case "ScrollBar":
-						if (readXmlAttr(extAttrs, EXTENSION_PROTOCOL_MAP$1.ScrollBar.attrs.fixedGripSize) !== void 0) comp.setFixedGripSize?.(parseBool(readXmlAttr(extAttrs, EXTENSION_PROTOCOL_MAP$1.ScrollBar.attrs.fixedGripSize)));
+						if (readXmlAttr(extAttrs, EXTENSION_PROTOCOL_MAP$1.ScrollBar.attrs.fixedGripSize) !== void 0) comp.setFixedGripSize?.(parseBool$1(readXmlAttr(extAttrs, EXTENSION_PROTOCOL_MAP$1.ScrollBar.attrs.fixedGripSize)));
 						break;
 					default: break;
 				}
@@ -18619,7 +20316,7 @@ function readComponentXml(ctx, comp, xmlContent) {
 					const repeat = readXmlAttr(actionDef, PROJECT_XML_PROTOCOL.controllerAction.attrs.repeat);
 					const delay = readXmlAttr(actionDef, PROJECT_XML_PROTOCOL.controllerAction.attrs.delay);
 					const stopOnExit = readXmlAttr(actionDef, PROJECT_XML_PROTOCOL.controllerAction.attrs.stopOnExit);
-					action.setTransitionName(getXmlScalar(transitionName)).setPlayTimes(parseInt2(repeat, 1)).setDelay(parseFloat2(delay)).setStopOnExit(parseBool(stopOnExit));
+					action.setTransitionName(getXmlScalar(transitionName)).setPlayTimes(parseInt2(repeat, 1)).setDelay(parseFloat2(delay)).setStopOnExit(parseBool$1(stopOnExit));
 					break;
 				}
 				case ControllerActionType.ChangePage: {
@@ -18661,7 +20358,7 @@ function readComponentXml(ctx, comp, xmlContent) {
 		const autoPlayDelay = readXmlAttr(transDef, PROJECT_XML_PROTOCOL.transition.attrs.autoPlayDelay);
 		const options = readXmlAttr(transDef, PROJECT_XML_PROTOCOL.transition.attrs.options);
 		const fps = readXmlAttr(transDef, PROJECT_XML_PROTOCOL.transition.attrs.fps);
-		trans.setAutoPlay(parseBool(autoPlay));
+		trans.setAutoPlay(parseBool$1(autoPlay));
 		trans.setAutoPlayTimes(parseInt2(autoPlayTimes, 1));
 		trans.setAutoPlayDelay(parseFloat2(autoPlayDelay));
 		if (options !== void 0) trans.setOptions?.(parseInt2(options));
@@ -18684,10 +20381,10 @@ function readComponentXml(ctx, comp, xmlContent) {
 			const customEaseValue = readXmlAttr(parsedItem, PROJECT_XML_PROTOCOL.transitionItem.attrs.customEase);
 			ti.setTime(parseFloat2(time));
 			ti.setTargetId(target || "");
-			ti.setTween(parseBool(tween));
+			ti.setTween(parseBool$1(tween));
 			ti.setDuration(parseFloat2(duration));
 			ti.setRepeat(parseInt2(repeat));
-			ti.setYoyo(parseBool(yoyo));
+			ti.setYoyo(parseBool$1(yoyo));
 			ti.setLabel(label || "");
 			if (label2 !== void 0) ti.setEndLabel?.(label2);
 			if (pathValue !== void 0) ti.setPath?.(pathValue);
@@ -18726,6 +20423,10 @@ function readComponentXml(ctx, comp, xmlContent) {
 }
 //#endregion
 //#region ../core/src/io/project-reader.ts
+function assertWellFormedXml(content) {
+	const result = XMLValidator.validate(content, { allowBooleanAttributes: true });
+	if (result !== true) throw new Error(result.err.msg);
+}
 function getOrderedPackageResourceItems(xmlContent) {
 	const descriptionEntry = parseXMLPreserveOrder(xmlContent).find((entry) => "packageDescription" in entry || "branchDescription" in entry);
 	if (!descriptionEntry) return [];
@@ -18778,18 +20479,60 @@ var ProjectReader = class {
 		this._fs = fs;
 	}
 	async read(projectPath, options = {}) {
+		return this._read(projectPath, options);
+	}
+	async readDetailed(projectPath, options = {}) {
+		const diagnostics = [];
+		try {
+			return {
+				document: await this._read(projectPath, options, diagnostics),
+				diagnostics,
+				complete: !diagnostics.some((diagnostic) => [
+					"invalid_project_xml",
+					"invalid_package_xml",
+					"invalid_branch_package_xml",
+					"invalid_component_xml",
+					"invalid_settings_json",
+					"unreadable_source",
+					"unsupported_resource_kind"
+				].includes(diagnostic.code))
+			};
+		} catch (error) {
+			diagnostics.push({
+				severity: "error",
+				code: "invalid_project_xml",
+				path: "project",
+				message: error instanceof Error ? error.message : String(error),
+				sourcePath: projectPath
+			});
+			return {
+				document: null,
+				diagnostics,
+				complete: false
+			};
+		}
+	}
+	async _read(projectPath, options, diagnostics) {
 		const fs = this._fs;
 		const doc = new Document();
 		const basePath = getProjectBasePath(fs, projectPath);
 		doc.setProjectDir(basePath);
-		const ctx = new ReaderContext(doc, basePath);
-		const projDesc = getXmlNode(parseXML(await fs.readFile(projectPath)).projectDescription);
+		const ctx = new ReaderContext(doc, basePath, diagnostics);
+		const fairyContent = await fs.readFile(projectPath);
+		if (diagnostics) assertWellFormedXml(fairyContent);
+		const projDesc = getXmlNode(parseXML(fairyContent).projectDescription);
 		if (projDesc) {
 			const root = doc.getRoot();
 			root.setProjectId(projDesc.id ?? "");
 			root.setProjectType(this._resolveProjectType(projDesc.type ?? ""));
 			root.setVersion(projDesc.version ?? "");
-		}
+		} else ctx.addDiagnostic({
+			severity: "error",
+			code: "invalid_project_xml",
+			path: "projectDescription",
+			message: "Project file must contain a projectDescription root element.",
+			sourcePath: projectPath
+		});
 		await this._readSettings(ctx);
 		const assetsPath = fs.join(basePath, "assets");
 		let packageDirs;
@@ -18801,9 +20544,20 @@ var ProjectReader = class {
 		for (const dirName of packageDirs) {
 			const pkgXmlPath = fs.join(assetsPath, dirName, "package.xml");
 			if (!await fs.exists(pkgXmlPath)) continue;
-			await this._readPackage(ctx, dirName, pkgXmlPath, "", options);
+			try {
+				await this._readPackage(ctx, dirName, pkgXmlPath, "", options, diagnostics !== void 0);
+			} catch (error) {
+				if (!diagnostics) throw error;
+				ctx.addDiagnostic({
+					severity: "error",
+					code: "invalid_package_xml",
+					path: `packages.${dirName}`,
+					message: error instanceof Error ? error.message : String(error),
+					sourcePath: pkgXmlPath
+				});
+			}
 		}
-		const branchNames = await this._readPackageBranches(ctx, options);
+		const branchNames = await this._readPackageBranches(ctx, options, diagnostics !== void 0);
 		if (branchNames.length > 0) doc.getRoot().setBranches(branchNames);
 		this._linkPackageBranchItems(doc);
 		for (const [_key, resource] of ctx.resourceMap) {
@@ -18812,9 +20566,22 @@ var ProjectReader = class {
 			const compPath = getProjectComponentExtras(comp)._filePath;
 			if (!compPath) continue;
 			try {
-				readComponentXml(ctx, comp, await fs.readFile(compPath));
+				const compContent = await fs.readFile(compPath);
+				if (diagnostics) {
+					assertWellFormedXml(compContent);
+					if (!getXmlNode(parseXML(compContent).component)) throw new Error("Component XML must contain a component root element.");
+				}
+				readComponentXml(ctx, comp, compContent);
 			} catch (err) {
 				ctx.logger.warn(`Failed to parse component: ${compPath} — ${err}`);
+				ctx.addDiagnostic({
+					severity: "error",
+					code: await fs.exists(compPath) ? "invalid_component_xml" : "missing_source",
+					path: `components.${comp.getId()}`,
+					message: `Failed to read component "${comp.getName()}": ${err instanceof Error ? err.message : String(err)}`,
+					resourceId: comp.getId(),
+					sourcePath: compPath
+				});
 			}
 		}
 		return doc;
@@ -18835,7 +20602,7 @@ var ProjectReader = class {
 			}
 		}
 	}
-	async _readPackageBranches(ctx, options) {
+	async _readPackageBranches(ctx, options, collectDiagnostics = false) {
 		const fs = this._fs;
 		let dirNames = [];
 		try {
@@ -18855,7 +20622,18 @@ var ProjectReader = class {
 			for (const dirName of packageDirs) {
 				const pkgXmlPath = fs.join(branchAssetsPath, dirName, "package_branch.xml");
 				if (!await fs.exists(pkgXmlPath)) continue;
-				await this._readPackage(ctx, dirName, pkgXmlPath, branchName, options);
+				try {
+					await this._readPackage(ctx, dirName, pkgXmlPath, branchName, options, collectDiagnostics);
+				} catch (error) {
+					if (!collectDiagnostics) throw error;
+					ctx.addDiagnostic({
+						severity: "error",
+						code: "invalid_branch_package_xml",
+						path: `branches.${branchName}.packages.${dirName}`,
+						message: error instanceof Error ? error.message : String(error),
+						sourcePath: pkgXmlPath
+					});
+				}
 			}
 		}
 		return branchNames;
@@ -18884,21 +20662,35 @@ var ProjectReader = class {
 				name: "i18n.json",
 				key: "i18n"
 			}
-		]) try {
+		]) {
 			const filePath = fs.join(settingsPath, name);
-			if (await fs.exists(filePath)) {
-				const content = await fs.readFile(filePath);
-				assignSetting(ctx.settings, key, JSON.parse(content));
+			try {
+				if (await fs.exists(filePath)) {
+					const content = await fs.readFile(filePath);
+					assignSetting(ctx.settings, key, JSON.parse(content));
+				}
+			} catch (error) {
+				ctx.addDiagnostic({
+					severity: "error",
+					code: "invalid_settings_json",
+					path: `settings.${name}`,
+					message: `Failed to read ${name}: ${error instanceof Error ? error.message : String(error)}`,
+					sourcePath: filePath
+				});
 			}
-		} catch {}
+		}
 		ctx.document.getRoot().setSettings(ctx.settings);
 	}
-	async _readPackage(ctx, dirName, pkgXmlPath, branchName = "", options = {}) {
+	async _readPackage(ctx, dirName, pkgXmlPath, branchName = "", options = {}, validateSyntax = false) {
 		const fs = this._fs;
 		const content = await fs.readFile(pkgXmlPath);
+		if (validateSyntax) assertWellFormedXml(content);
 		const xml = parseXML(content);
 		const desc = branchName ? getXmlNode(xml.branchDescription) : getXmlNode(xml.packageDescription);
-		if (!desc) return;
+		if (!desc) {
+			if (validateSyntax) throw new Error(`Package XML must contain a ${branchName ? "branchDescription" : "packageDescription"} root element.`);
+			return;
+		}
 		let pkg = ctx.document.getRoot().getPackage(dirName);
 		if (!pkg) pkg = ctx.document.createPackage(dirName);
 		if (branchName) pkg.addBranchName(branchName);
@@ -18921,7 +20713,7 @@ var ProjectReader = class {
 				pkg.setBranchNames(parsedBranchNames);
 			}
 			const compressPNG = readXmlAttr(desc, PROJECT_XML_PROTOCOL.packageDescription.attrs.compressPNG);
-			if (compressPNG !== void 0) pkg.setCompressPNG(parseBool(compressPNG));
+			if (compressPNG !== void 0) pkg.setCompressPNG(parseBool$1(compressPNG));
 			const jpegQuality = readXmlAttr(desc, PROJECT_XML_PROTOCOL.packageDescription.attrs.jpegQuality);
 			if (jpegQuality !== void 0 && jpegQuality !== null && jpegQuality !== "") pkg.setJpegQuality(parseInt2(jpegQuality, 0));
 		}
@@ -18932,11 +20724,11 @@ var ProjectReader = class {
 			pkg.setPublishPath(readXmlAttr(publish, PROJECT_XML_PROTOCOL.packagePublish.attrs.path) || "");
 			pkg.setPublishBranchPath(readXmlAttr(publish, PROJECT_XML_PROTOCOL.packagePublish.attrs.branchPath) || "");
 			pkg.setPublishPackageCount(parseInt2(readXmlAttr(publish, PROJECT_XML_PROTOCOL.packagePublish.attrs.packageCount), 0));
-			pkg.setGenCode(parseBool(readXmlAttr(publish, PROJECT_XML_PROTOCOL.packagePublish.attrs.genCode)));
+			pkg.setGenCode(parseBool$1(readXmlAttr(publish, PROJECT_XML_PROTOCOL.packagePublish.attrs.genCode)));
 			pkg.setCodePath(readXmlAttr(publish, PROJECT_XML_PROTOCOL.packagePublish.attrs.codePath) || "");
 			const globalAtlas = ctx.settings.publish?.atlasSetting;
 			const maxAtlasSize = readXmlAttr(publish, PROJECT_XML_PROTOCOL.packagePublish.attrs.maxAtlasSize);
-			const sizeOption = parseBool(readXmlAttr(publish, PROJECT_XML_PROTOCOL.packagePublish.attrs.npot)) ? "npot" : readXmlAttr(publish, PROJECT_XML_PROTOCOL.packagePublish.attrs.sizeOption) || globalAtlas?.sizeOption || "pot";
+			const sizeOption = parseBool$1(readXmlAttr(publish, PROJECT_XML_PROTOCOL.packagePublish.attrs.npot)) ? "npot" : readXmlAttr(publish, PROJECT_XML_PROTOCOL.packagePublish.attrs.sizeOption) || globalAtlas?.sizeOption || "pot";
 			const square = readXmlAttr(publish, PROJECT_XML_PROTOCOL.packagePublish.attrs.square);
 			const rotation = readXmlAttr(publish, PROJECT_XML_PROTOCOL.packagePublish.attrs.rotation);
 			const multiPage = readXmlAttr(publish, PROJECT_XML_PROTOCOL.packagePublish.attrs.multiPage);
@@ -18944,10 +20736,10 @@ var ProjectReader = class {
 				useGlobal: maxAtlasSize === void 0,
 				maxSize: parseInt2(maxAtlasSize, globalAtlas?.maxSize ?? 2048),
 				sizeOption: sizeOption === "npot" || sizeOption === "mof" ? sizeOption : "pot",
-				forceSquare: square === void 0 ? globalAtlas?.forceSquare ?? false : parseBool(square),
-				allowRotation: rotation === void 0 ? globalAtlas?.allowRotation ?? false : parseBool(rotation),
-				paging: multiPage === void 0 ? globalAtlas?.paging ?? true : parseBool(multiPage),
-				extractAlpha: parseBool(readXmlAttr(publish, PROJECT_XML_PROTOCOL.packagePublish.attrs.extractAlpha)),
+				forceSquare: square === void 0 ? globalAtlas?.forceSquare ?? false : parseBool$1(square),
+				allowRotation: rotation === void 0 ? globalAtlas?.allowRotation ?? false : parseBool$1(rotation),
+				paging: multiPage === void 0 ? globalAtlas?.paging ?? true : parseBool$1(multiPage),
+				extractAlpha: parseBool$1(readXmlAttr(publish, PROJECT_XML_PROTOCOL.packagePublish.attrs.extractAlpha)),
 				maxIndex: parseInt2(readXmlAttr(publish, PROJECT_XML_PROTOCOL.packagePublish.attrs.maxAtlasIndex), 10),
 				atlases: ensureArray(publish.atlas).flatMap((value) => {
 					const atlas = getXmlNode(value);
@@ -18955,7 +20747,7 @@ var ProjectReader = class {
 					return [{
 						index: parseInt2(readXmlAttr(atlas, PROJECT_XML_PROTOCOL.packagePublishAtlas.attrs.index)),
 						name: readXmlAttr(atlas, PROJECT_XML_PROTOCOL.packagePublishAtlas.attrs.name) || "",
-						compression: parseBool(readXmlAttr(atlas, PROJECT_XML_PROTOCOL.packagePublishAtlas.attrs.compression))
+						compression: parseBool$1(readXmlAttr(atlas, PROJECT_XML_PROTOCOL.packagePublishAtlas.attrs.compression))
 					}];
 				}),
 				excludedResourceIds: (readXmlAttr(publish, PROJECT_XML_PROTOCOL.packagePublish.attrs.excluded) || "").split(",").filter(Boolean)
@@ -18976,7 +20768,7 @@ var ProjectReader = class {
 				if (resource) createdResources.push(resource);
 			}
 			await this._hydratePackageImageSizes(createdResources, packageDir);
-			if (options.hydrateResourceBytes) await this._hydratePackageResourceBytes(ctx.document, createdResources, packageDir);
+			if (options.hydrateResourceBytes) await this._hydratePackageResourceBytes(ctx, createdResources, packageDir, pkg.getId());
 			return;
 		}
 		for (const tagName of [
@@ -19000,7 +20792,7 @@ var ProjectReader = class {
 			}
 		}
 		await this._hydratePackageImageSizes(createdResources, packageDir);
-		if (options.hydrateResourceBytes) await this._hydratePackageResourceBytes(ctx.document, createdResources, packageDir);
+		if (options.hydrateResourceBytes) await this._hydratePackageResourceBytes(ctx, createdResources, packageDir, pkg.getId());
 	}
 	async _readPackageFolders(pkg, packageDir, branch, metadataEntries) {
 		const metadata = new Map(metadataEntries.map((attrs) => {
@@ -19027,7 +20819,7 @@ var ProjectReader = class {
 				folders.push({
 					branch,
 					path,
-					favorite: parseBool(readXmlAttr(attrs ?? {}, PROJECT_XML_PROTOCOL.packageResourceFolder.attrs.favorite)),
+					favorite: parseBool$1(readXmlAttr(attrs ?? {}, PROJECT_XML_PROTOCOL.packageResourceFolder.attrs.favorite)),
 					atlas: readXmlAttr(attrs ?? {}, PROJECT_XML_PROTOCOL.packageResourceFolder.attrs.atlas) ?? ""
 				});
 				await visit(childDirectory, path, childEntries);
@@ -19057,8 +20849,9 @@ var ProjectReader = class {
 			} catch {}
 		}
 	}
-	async _hydratePackageResourceBytes(doc, resources, packageDir) {
+	async _hydratePackageResourceBytes(ctx, resources, packageDir, packageId) {
 		const fs = this._fs;
+		const doc = ctx.document;
 		for (const resource of resources) {
 			const fileName = this._primaryResourceFileName(resource);
 			if (!fileName) continue;
@@ -19066,7 +20859,18 @@ var ProjectReader = class {
 			const sourcePath = this._packageRelativeSourcePath(resourcePath, fileName);
 			if (!sourcePath) continue;
 			const filePath = fs.join(packageDir, sourcePath.replace(/^\/+/, ""));
-			if (!await fs.exists(filePath)) continue;
+			if (!await fs.exists(filePath)) {
+				ctx.addDiagnostic({
+					severity: "error",
+					code: "missing_source",
+					path: `packages.${packageId}.resources.${resource.getId()}`,
+					message: `Declared source file is missing: ${sourcePath}`,
+					packageId,
+					resourceId: resource.getId(),
+					sourcePath: filePath
+				});
+				continue;
+			}
 			try {
 				const data = new Uint8Array(await fs.readFileRaw(filePath));
 				const buffer = doc.createBuffer().setURI(sourcePath).setData(data);
@@ -19076,8 +20880,28 @@ var ProjectReader = class {
 					if (size) resource.setWidth(size.width).setHeight(size.height);
 				} else if (resource.propertyType === "MovieClipResource") try {
 					applyDerivedMovieClipModel(doc, resource, deriveMovieClipModelFromJta(data));
-				} catch {}
-			} catch {}
+				} catch (error) {
+					ctx.addDiagnostic({
+						severity: "error",
+						code: "corrupt_source",
+						path: `packages.${packageId}.resources.${resource.getId()}`,
+						message: `MovieClip source is invalid: ${error instanceof Error ? error.message : String(error)}`,
+						packageId,
+						resourceId: resource.getId(),
+						sourcePath: filePath
+					});
+				}
+			} catch (error) {
+				ctx.addDiagnostic({
+					severity: "error",
+					code: "unreadable_source",
+					path: `packages.${packageId}.resources.${resource.getId()}`,
+					message: `Declared source file cannot be read: ${error instanceof Error ? error.message : String(error)}`,
+					packageId,
+					resourceId: resource.getId(),
+					sourcePath: filePath
+				});
+			}
 		}
 	}
 	_primaryResourceFileName(resource) {
@@ -19107,8 +20931,8 @@ var ProjectReader = class {
 		const id = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.packageResource.attrs.id) ?? "";
 		const name = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.packageResource.attrs.name) ?? "";
 		const path = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.packageResource.attrs.path) ?? "/";
-		const exported = parseBool(readXmlAttr(attrs, PROJECT_XML_PROTOCOL.packageResource.attrs.exported));
-		const favorite = parseBool(readXmlAttr(attrs, PROJECT_XML_PROTOCOL.packageResource.attrs.favorite));
+		const exported = parseBool$1(readXmlAttr(attrs, PROJECT_XML_PROTOCOL.packageResource.attrs.exported));
+		const favorite = parseBool$1(readXmlAttr(attrs, PROJECT_XML_PROTOCOL.packageResource.attrs.favorite));
 		switch (tagName) {
 			case "image": {
 				const res = doc.createImageResource(name.replace(/\.\w+$/, ""));
@@ -19136,7 +20960,7 @@ var ProjectReader = class {
 				if (qualityOption !== void 0) res.setQualityOption(qualityOption);
 				const quality = readXmlAttr(attrs, PROJECT_XML_PROTOCOL.packageImageResource.attrs.quality);
 				if (quality !== void 0) res.setQuality(parseInt2(quality));
-				res.setDuplicatePadding(parseBool(readXmlAttr(attrs, PROJECT_XML_PROTOCOL.packageImageResource.attrs.duplicatePadding)));
+				res.setDuplicatePadding(parseBool$1(readXmlAttr(attrs, PROJECT_XML_PROTOCOL.packageImageResource.attrs.duplicatePadding)));
 				res.setSmoothing(readXmlAttr(attrs, PROJECT_XML_PROTOCOL.packageImageResource.attrs.smoothing) !== "false");
 				pkg.addResource(res);
 				ctx.registerResource(pkg.getId(), id, res);
@@ -19262,7 +21086,17 @@ var ProjectReader = class {
 				ctx.registerResource(pkg.getId(), id, res);
 				return res;
 			}
-			default: return null;
+			default:
+				ctx.addDiagnostic({
+					severity: "error",
+					code: "unsupported_resource_kind",
+					path: `packages.${pkg.getId()}.resources.${id || name}`,
+					message: `Unsupported declared resource kind "${tagName}".`,
+					packageId: pkg.getId(),
+					resourceId: id,
+					sourcePath: fs.join(packageDir, path.replace(/^\//, ""), name)
+				});
+				return null;
 		}
 	}
 	_resolveProjectType(typeStr) {
@@ -24923,6 +26757,9 @@ var PlatformIO = class {
 	async readProject(projectPath, options) {
 		return new ProjectReader(this.createFileSystem()).read(projectPath, options);
 	}
+	async readProjectDetailed(projectPath, options) {
+		return new ProjectReader(this.createFileSystem()).readDetailed(projectPath, options);
+	}
 	async writeProject(doc, projectPath, options) {
 		return new ProjectWriter(this.createFileSystem()).write(doc, projectPath, options);
 	}
@@ -24934,6 +26771,66 @@ var PlatformIO = class {
 	}
 };
 //#endregion
+//#region ../functions/src/validate.ts
+/** Validate one authoritative UAM snapshot without mutating it. */
+function validateProject(project, options = {}) {
+	const diagnostics = [
+		...options.readDiagnostics ?? [],
+		...validateUamProject(project),
+		...validateUamReferences(project)
+	];
+	let complete = options.complete ?? true;
+	if (options.validateSources) {
+		const source = validateUamSourceBytes(project);
+		diagnostics.push(...source.diagnostics);
+		complete = complete && source.complete;
+	}
+	return createProjectValidationReport(diagnostics, complete);
+}
+//#endregion
+//#region ../functions/src/utils.ts
+/**
+* Wraps a transform function, assigning it a name for the transform stack.
+*/
+function createTransform(name, fn) {
+	Object.defineProperty(fn, "name", { value: name });
+	return fn;
+}
+function parseTextureSetMode(value) {
+	const raw = value?.trim() ?? "";
+	if (!raw) return {
+		kind: "auto",
+		raw: ""
+	};
+	if (raw === "alone") return {
+		kind: "standalone",
+		raw,
+		sizeMode: "default"
+	};
+	if (raw === "alone_npot") return {
+		kind: "standalone",
+		raw,
+		sizeMode: "npot"
+	};
+	if (raw === "alone_mof") return {
+		kind: "standalone",
+		raw,
+		sizeMode: "multipleOf4"
+	};
+	if (/^\d+$/.test(raw)) {
+		const pageIndex = Number(raw);
+		if (pageIndex >= 0 && pageIndex <= 10) return {
+			kind: "page",
+			raw,
+			pageIndex
+		};
+	}
+	return {
+		kind: "auto",
+		raw
+	};
+}
+//#endregion
 //#region ../functions/src/publish/resource-references.ts
 function addReference(target, ownerPackageId, packageId, resourceId) {
 	if (!packageId || !resourceId) return;
@@ -29090,11 +30987,11 @@ function printReport(report) {
 }
 //#endregion
 //#region ../functions/src/adapters/node/plugins.ts
-const importNative$2 = new Function("id", "return import(id)");
+const importNative$3 = new Function("id", "return import(id)");
 async function loadPlugins(doc, pluginsDir) {
 	if (!pluginsDir) return [];
-	const fs = await importNative$2("node:fs/promises");
-	const path = await importNative$2("node:path");
+	const fs = await importNative$3("node:fs/promises");
+	const path = await importNative$3("node:path");
 	let entries;
 	try {
 		entries = await fs.readdir(pluginsDir, { withFileTypes: true });
@@ -29134,7 +31031,7 @@ function resolvePluginMain(path, pluginDir, manifest) {
 	return mainPath;
 }
 async function loadPlugin(mainPath) {
-	const { createJiti } = await importNative$2("jiti");
+	const { createJiti } = await importNative$3("jiti");
 	const mod = await createJiti(import.meta.url).import(mainPath);
 	const defaultExport = mod.default;
 	return isObject(defaultExport) ? defaultExport : mod;
@@ -29144,9 +31041,9 @@ function isObject(value) {
 }
 //#endregion
 //#region ../functions/src/adapters/node/publish.ts
-const importNative$1 = new Function("id", "return import(id)");
+const importNative$2 = new Function("id", "return import(id)");
 async function createNodePublishFileSystem() {
-	const [fs, path] = await Promise.all([importNative$1("node:fs/promises"), importNative$1("node:path")]);
+	const [fs, path] = await Promise.all([importNative$2("node:fs/promises"), importNative$2("node:path")]);
 	return {
 		async readFileRaw(filePath) {
 			const data = await fs.readFile(filePath);
@@ -29174,11 +31071,11 @@ async function resolveNodeAssetsPath(document, assetsPath) {
 	if (assetsPath) return assetsPath;
 	const projectDir = document.getProjectDir?.() ?? "";
 	if (!projectDir) return void 0;
-	return (await importNative$1("node:path")).join(projectDir, "assets");
+	return (await importNative$2("node:path")).join(projectDir, "assets");
 }
 async function loadSharpBackend() {
 	try {
-		const loaded = await importNative$1("sharp");
+		const loaded = await importNative$2("sharp");
 		return loaded.default ?? loaded;
 	} catch {
 		return;
@@ -29187,7 +31084,7 @@ async function loadSharpBackend() {
 async function loadNodePublishPlugins(document, assetsPath) {
 	const projectDir = document.getProjectDir?.() || (assetsPath ? resolveProjectBasePath(assetsPath) : "");
 	if (!projectDir) return [];
-	return loadPlugins(document, (await importNative$1("node:path")).join(projectDir, "plugins"));
+	return loadPlugins(document, (await importNative$2("node:path")).join(projectDir, "plugins"));
 }
 /**
 * Publish a FairyGUI project through the standard Node host adapter.
@@ -29215,9 +31112,9 @@ async function publishNode(options) {
 }
 //#endregion
 //#region ../functions/src/adapters/node/restore.ts
-const importNative = new Function("id", "return import(id)");
+const importNative$1 = new Function("id", "return import(id)");
 async function createNodeRestoreFileSystem() {
-	const [fs, path] = await Promise.all([importNative("node:fs/promises"), importNative("node:path")]);
+	const [fs, path] = await Promise.all([importNative$1("node:fs/promises"), importNative$1("node:path")]);
 	return {
 		async readFile(filePath) {
 			return fs.readFile(filePath, "utf-8");
@@ -29282,7 +31179,7 @@ async function createNodeRestoreFileSystem() {
 async function createRestoreImageProcessors() {
 	let sharp;
 	try {
-		const loaded = await importNative("sharp");
+		const loaded = await importNative$1("sharp");
 		sharp = loaded.default ?? loaded;
 	} catch {
 		throw new Error("restoreNode: Sharp is required to crop atlas images. Install sharp before restoring.");
@@ -29320,8 +31217,8 @@ async function createRestoreImageProcessors() {
 		if (input.expectedWidth > 0 && input.expectedHeight > 0 && (info.width !== input.expectedWidth || info.height !== input.expectedHeight)) throw new Error(`restore: Cropped image size mismatch for ${targetPath}: expected ${input.expectedWidth}x${input.expectedHeight}, got ${info.width}x${info.height}`);
 		return data;
 	}
-	const fs = await importNative("node:fs/promises");
-	const path = await importNative("node:path");
+	const fs = await importNative$1("node:fs/promises");
+	const path = await importNative$1("node:path");
 	return {
 		extractImage,
 		cropImage: async (input) => {
@@ -29340,6 +31237,70 @@ async function restoreNode(options) {
 	});
 }
 //#endregion
+//#region ../functions/src/adapters/node/validate.ts
+const importNative = new Function("id", "return import(id)");
+function sourceName(resource) {
+	return resource.sourcePath ?? resource.fileName ?? resource.file ?? resource.name;
+}
+async function validateProjectNode(projectPath) {
+	const read = await new NodeIO().readProjectDetailed(projectPath, { hydrateResourceBytes: true });
+	if (!read.document) return createProjectValidationReport(read.diagnostics, false);
+	let project;
+	try {
+		project = liftDocumentToUamProject(read.document);
+	} catch (error) {
+		return createProjectValidationReport([...read.diagnostics, {
+			severity: "error",
+			code: "invalid_uam",
+			path: "project",
+			message: `Project cannot be represented as UAM: ${error instanceof Error ? error.message : String(error)}`,
+			sourcePath: projectPath
+		}], false);
+	}
+	const base = validateProject(project, {
+		readDiagnostics: read.diagnostics,
+		complete: read.complete,
+		validateSources: true
+	});
+	let diagnostics = base.diagnostics;
+	const knownCorruptPaths = new Set(base.diagnostics.filter((diagnostic) => diagnostic.code === "corrupt_source").map((diagnostic) => diagnostic.path));
+	const images = project.packages.flatMap((pkg, packageIndex) => pkg.resources.map((resource, resourceIndex) => ({
+		pkg,
+		packageIndex,
+		resource,
+		resourceIndex
+	})).filter(({ resource, packageIndex, resourceIndex }) => resource.kind === "image" && resource.sourceBytes instanceof Uint8Array && !knownCorruptPaths.has(`packages[${packageIndex}].resources[${resourceIndex}]`)));
+	if (images.length === 0) return base;
+	let sharp;
+	try {
+		const loaded = await importNative("sharp");
+		sharp = loaded.default ?? loaded;
+	} catch {
+		return createProjectValidationReport([...base.diagnostics, {
+			severity: "warning",
+			code: "decode_capability_unavailable",
+			path: "project",
+			message: "Sharp is unavailable, so Node image decoding could not be completed."
+		}], false);
+	}
+	const decodedPaths = new Set(images.map(({ packageIndex, resourceIndex }) => `packages[${packageIndex}].resources[${resourceIndex}]`));
+	diagnostics = diagnostics.filter((diagnostic) => diagnostic.code !== "decode_capability_unavailable" || !decodedPaths.has(diagnostic.path));
+	for (const { pkg, packageIndex, resource, resourceIndex } of images) try {
+		await sharp(resource.sourceBytes).raw().toBuffer();
+	} catch (error) {
+		diagnostics.push({
+			severity: "error",
+			code: "corrupt_source",
+			path: `packages[${packageIndex}].resources[${resourceIndex}]`,
+			message: `Image source cannot be decoded: ${error instanceof Error ? error.message : String(error)}`,
+			packageId: pkg.id,
+			resourceId: resource.id,
+			sourcePath: sourceName(resource)
+		});
+	}
+	return createProjectValidationReport(diagnostics, read.complete && !diagnostics.some((diagnostic) => diagnostic.code === "decode_capability_unavailable"));
+}
+//#endregion
 //#region src/utils/project-type.ts
 function parseProjectType(value) {
 	if (!value) return void 0;
@@ -29422,10 +31383,27 @@ function registerRestoreCommand(program) {
 	});
 }
 //#endregion
+//#region src/commands/validate.ts
+function registerValidateCommand(program) {
+	program.command("validate").description("Validate project structure, references, and source files").argument("<project-dir>", "Project root directory or .fairy file").option("--json", "Print the machine-readable validation report").action(async (projectDir, options) => {
+		const fairyPath = await resolveFairyPath(projectDir);
+		const report = await validateProjectNode(fairyPath);
+		if (options.json) console.log(JSON.stringify(report, null, 2));
+		else {
+			console.log(`${report.status.toUpperCase()}: ${fairyPath}`);
+			for (const diagnostic of report.diagnostics) {
+				const source = diagnostic.sourcePath ? ` (${diagnostic.sourcePath})` : "";
+				console.log(`${diagnostic.severity.toUpperCase()} ${diagnostic.code} ${diagnostic.path}${source}: ${diagnostic.message}`);
+			}
+		}
+		process.exitCode = report.status === "valid" ? 0 : report.status === "invalid" ? 1 : 2;
+	});
+}
+//#endregion
 //#region src/utils/package-version.ts
 const require$1 = createRequire(import.meta.url);
 function getInjectedPackageVersion() {
-	const version = "0.2.0";
+	const version = "0.3.0-alpha.2";
 	return typeof version === "string" && true ? version : null;
 }
 function readPackageVersion() {
@@ -29446,6 +31424,7 @@ function createProgram() {
 	registerInspectCommand(program);
 	registerPublishCommand(program);
 	registerRestoreCommand(program);
+	registerValidateCommand(program);
 	registerBackendCapabilitiesCommand(program);
 	program.addHelpText("after", [
 		"",