@openfairygui/functions 0.2.0-alpha.0 → 0.2.0-alpha.11

package/dist/index.js

@@ -1,4 +1,6 @@
-import { BinaryReader, BinaryWriter, GearType, ProjectType, ProjectWriter, TransitionActionType, UamTransactionError, applyUamTransaction, generateId } from "@openfairygui/core";
+import { applyUamTransactionApp } from "./uam-transaction.js";
+import { BinaryReader, BinaryWriter, GearType, ProjectType, ProjectWriter, TransitionActionType, generateId } from "@openfairygui/core";
+import { createJiti } from "jiti";
 //#region src/inspect.ts
 function mapResource(resource) {
 	return {
@@ -109,6 +111,40 @@ 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 src/validate.ts
 /**
@@ -1040,6 +1076,19 @@ const ATLAS_DEFAULTS = {
 function getPublishedItemId(resource) {
 	return (resource.getExtras() ?? {})._publishedId ?? resource.getId();
 }
+function getSelectedSkeletonDependencyImageIds(resources) {
+	const imageIds = /* @__PURE__ */ new Set();
+	const resourcesById = new Map(resources.map((resource) => [resource.getId(), resource]));
+	for (const resource of resources) {
+		if (!isSkeletonResource$1(resource)) continue;
+		for (const requiredId of resource.getRequireIds()) {
+			if (!requiredId) continue;
+			const required = resourcesById.get(requiredId);
+			if (required && isImageResource$1(required)) imageIds.add(requiredId);
+		}
+	}
+	return imageIds;
+}
 function resolveFontFileName(fontName) {
 	return /\.fnt$/i.test(fontName) ? fontName : `${fontName}.fnt`;
 }
@@ -1176,12 +1225,18 @@ function atlas(_options = {}) {
 		const logger = doc.getLogger();
 		const encoder = options.encoder;
 		const doTrim = options.trimImage && !!encoder && !!options.basePath;
+		const packageFilter = options.packages ? new Set(options.packages) : null;
 		for (const pkg of root.listPackages()) {
+			if (packageFilter && !packageFilter.has(pkg.getName())) continue;
 			const selectedPublishIds = new Set((pkg.getExtras() ?? {}).publishedResourceIds ?? []);
 			const allResources = selectedPublishIds.size > 0 ? pkg.listResources().filter((resource) => selectedPublishIds.has(resource.getId())) : pkg.listResources();
+			const skeletonDependencyImageIds = getSelectedSkeletonDependencyImageIds(allResources);
 			const orderedResources = await resolveEditorCompatibleResourceOrder(pkg, allResources, options);
 			const orderedAllResources = sortResourcesByOrder(allResources, new Map(orderedResources.map((resource, index) => [resource.getId(), index])), new Map(allResources.map((resource, index) => [resource.getId(), index])));
-			if (!allResources.some((resource) => isPackableResource(resource))) continue;
+			if (!allResources.some((resource) => {
+				if (isImageResource$1(resource) && skeletonDependencyImageIds.has(resource.getId())) return false;
+				return isPackableResource(resource);
+			})) continue;
 			const inputs = [];
 			const referencedIds = /* @__PURE__ */ new Set();
 			const resourceMap = /* @__PURE__ */ new Map();
@@ -1250,148 +1305,72 @@ function atlas(_options = {}) {
 			}
 			for (const res of orderedAllResources) if (isImageResource$1(res)) {
 				const resId = res.getId();
-				if (!res.getExported() && referencedIds.size > 0 && !referencedIds.has(resId)) continue;
+				if (skeletonDependencyImageIds.has(resId)) continue;
+				if (selectedPublishIds.size === 0 && !res.getExported() && referencedIds.size > 0 && !referencedIds.has(resId)) continue;
 				await _collectImage(res, pkg, inputs, encoder, options, doTrim, logger);
 			} else if (isMovieClipResource$1(res)) {
 				const resId = res.getId();
-				if (!res.getExported() && referencedIds.size > 0 && !referencedIds.has(resId)) continue;
+				if (selectedPublishIds.size === 0 && !res.getExported() && referencedIds.size > 0 && !referencedIds.has(resId)) continue;
 				await _collectMovieClipFrames(doc, res, pkg, inputs, encoder, options, logger);
 			} else if (isFontResource$1(res)) {
 				const resId = res.getId();
-				if (!res.getExported() && referencedIds.size > 0 && !referencedIds.has(resId)) continue;
+				if (selectedPublishIds.size === 0 && !res.getExported() && referencedIds.size > 0 && !referencedIds.has(resId)) continue;
 				await _collectFontTexture(doc, res, pkg, options);
 			}
 			if (inputs.length === 0) continue;
-			const branchGroups = buildBranchAtlasGroups(doc, inputs, options);
 			let totalPageCount = 0;
 			let usedDirectOutput = false;
+			const { autoInputs, fixedPageGroups, standaloneGroups, reservedPageIndexes } = groupStandaloneInputs(doc, inputs, options);
+			const branchGroups = buildBranchAtlasGroups(doc, autoInputs, options);
+			const branchPageOffsets = /* @__PURE__ */ new Map();
 			for (const group of branchGroups) {
-				const directOutput = resolveDirectImageOutput(group.inputs, options);
+				const directOutput = fixedPageGroups.length === 0 && standaloneGroups.length === 0 ? resolveDirectImageOutput(group.inputs, options) : null;
 				if (directOutput) {
 					await emitDirectImageOutput(doc, pkg, directOutput, encoder, options, logger, group.branchName, group.branchOrdinal);
 					usedDirectOutput = true;
 					totalPageCount += 1;
 					continue;
 				}
-				const hasDuplicatePadding = group.inputs.some((i) => {
-					return isImageResource$1(i.resource) && i.resource.getDuplicatePadding?.() === true;
+				const pageStart = reserveAutoPageStart(branchPageOffsets, group.branchOrdinal, reservedPageIndexes);
+				const emittedPageCount = await emitPagedAtlasGroup(doc, pkg, allResources, group.inputs, {
+					branchName: group.branchName,
+					branchOrdinal: group.branchOrdinal,
+					pageStart,
+					fileNameAt: (pageIndex) => resolveAtlasOutputFileName(pkg, pageIndex, group.branchName),
+					options,
+					encoder,
+					logger
 				});
-				const pages = new MaxRectsPackerCompat({
-					pot: options.powerOfTwo,
-					mof: !options.powerOfTwo,
-					padding: options.padding,
-					rotation: options.allowRotation,
-					minWidth: 16,
-					minHeight: 16,
-					maxWidth: options.maxSize,
-					maxHeight: options.maxSize,
-					square: options.square,
-					fast: options.fast,
-					edgePadding: false,
-					duplicatePadding: hasDuplicatePadding,
-					multiPage: options.multiPage,
-					preserveInputOrderOnTie: options.preserveInputOrderOnTie
-				}).pack(group.inputs.map((input, index) => inputToCompatRect(input, index)));
-				if (!pages || pages.length === 0) continue;
-				totalPageCount += pages.length;
-				for (let p = 0; p < pages.length; p++) {
-					const page = pages[p];
-					const atlasNode = doc.createAtlas(`atlas${resolveAtlasIndex(group.branchOrdinal, p)}`);
-					atlasNode.setIndex(resolveAtlasIndex(group.branchOrdinal, p));
-					atlasNode.setFile(resolveAtlasOutputFileName(pkg, p, group.branchName));
-					atlasNode.setWidth(page.width);
-					atlasNode.setHeight(page.height);
-					pkg.addAtlas(atlasNode);
-					for (const pr of page.outputRects) {
-						const input = group.inputs[pr.index];
-						if (!input) continue;
-						const packedSize = resolvePackedRectSize(input, pr.width, pr.height, pr.rotated);
-						const rotated = pr.rotated;
-						const sprite = doc.createSprite();
-						sprite.setItemId(input.id);
-						sprite.setRectX(pr.x);
-						sprite.setRectY(pr.y);
-						sprite.setRectWidth(packedSize.width);
-						sprite.setRectHeight(packedSize.height);
-						sprite.setRotated(rotated);
-						sprite.setOffsetX(input.offsetX);
-						sprite.setOffsetY(input.offsetY);
-						sprite.setOriginalWidth(input.originalWidth);
-						sprite.setOriginalHeight(input.originalHeight);
-						sprite.setAtlas(atlasNode);
-						atlasNode.addSprite(sprite);
-					}
-					for (const res of allResources) {
-						if (!isFontResource$1(res)) continue;
-						const alias = res.getExtras()?._fontSpriteAlias;
-						if (!alias) continue;
-						const imgSprite = page.outputRects.find((result) => group.inputs[result.index]?.id === alias.textureId);
-						if (!imgSprite) continue;
-						const imgInput = group.inputs[imgSprite.index];
-						const fontSprite = doc.createSprite();
-						fontSprite.setItemId(alias.fontId);
-						fontSprite.setRectX(imgSprite.x);
-						fontSprite.setRectY(imgSprite.y);
-						fontSprite.setRectWidth(imgSprite.width);
-						fontSprite.setRectHeight(imgSprite.height);
-						fontSprite.setRotated(imgSprite.rotated);
-						if (imgInput) {
-							fontSprite.setOffsetX(imgInput.offsetX);
-							fontSprite.setOffsetY(imgInput.offsetY);
-							fontSprite.setOriginalWidth(imgInput.originalWidth);
-							fontSprite.setOriginalHeight(imgInput.originalHeight);
-						}
-						fontSprite.setAtlas(atlasNode);
-						atlasNode.addSprite(fontSprite);
-					}
-				}
-				if (encoder && options.outputPath) {
-					if (options.mkdir) await options.mkdir(options.outputPath);
-					for (let p = 0; p < pages.length; p++) {
-						const page = pages[p];
-						const compositeInputs = [];
-						for (const pr of page.outputRects) {
-							const input = group.inputs[pr.index];
-							if (!input) continue;
-							if (pr.width <= 0 || pr.height <= 0 || input.width <= 0 || input.height <= 0) continue;
-							try {
-								let imgBuffer;
-								if (input.trimBuffer) {
-									imgBuffer = input.trimBuffer;
-									if (imgBuffer.length === 0) continue;
-								} else {
-									if (!isImageResource$1(input.resource)) {
-										logger.warn(`atlas: Non-image input "${input.id}" is missing inline buffer, skipping compositing.`);
-										continue;
-									}
-									imgBuffer = await encoder(_resolveImagePath(input.resource, pkg, options.basePath)).toBuffer();
-								}
-								if (pr.rotated) imgBuffer = await encoder(imgBuffer).rotate(270).toBuffer();
-								compositeInputs.push({
-									input: imgBuffer,
-									left: pr.x,
-									top: pr.y
-								});
-							} catch {
-								logger.warn(`atlas: Could not read image "${input.id}" for compositing.`);
-							}
-						}
-						const atlasFileName = resolveAtlasOutputFileName(pkg, p, group.branchName);
-						const outputFile = `${options.outputPath}/${atlasFileName}`;
-						await encoder({ create: {
-							width: page.width,
-							height: page.height,
-							channels: 4,
-							background: {
-								r: 0,
-								g: 0,
-								b: 0,
-								alpha: 0
-							}
-						} }).composite(compositeInputs).png().toFile(outputFile);
-						logger.info(`atlas: Generated ${atlasFileName} (${page.width}x${page.height}, ${page.outputRects.length} sprites)`);
-					}
-				}
+				totalPageCount += emittedPageCount;
+				branchPageOffsets.set(group.branchOrdinal, pageStart + emittedPageCount);
+			}
+			for (const group of fixedPageGroups) {
+				const emittedPageCount = await emitPagedAtlasGroup(doc, pkg, allResources, group.inputs, {
+					branchName: group.branchName,
+					branchOrdinal: group.branchOrdinal,
+					pageStart: group.pageIndex,
+					forceSinglePage: true,
+					fileNameAt: () => resolveAtlasOutputFileName(pkg, group.pageIndex, group.branchName),
+					options,
+					encoder,
+					logger
+				});
+				totalPageCount += emittedPageCount;
+			}
+			const standalonePageOffsets = new Map(branchPageOffsets);
+			for (const group of fixedPageGroups) {
+				const nextPageIndex = group.pageIndex + 1;
+				if (nextPageIndex > (standalonePageOffsets.get(group.branchOrdinal) ?? 0)) standalonePageOffsets.set(group.branchOrdinal, nextPageIndex);
+			}
+			for (const group of standaloneGroups) {
+				const emittedPageCount = await emitStandaloneAtlasGroup(doc, pkg, group, {
+					atlasIndexStart: standalonePageOffsets.get(group.branchOrdinal) ?? 0,
+					options,
+					encoder,
+					logger
+				});
+				totalPageCount += emittedPageCount;
+				standalonePageOffsets.set(group.branchOrdinal, (standalonePageOffsets.get(group.branchOrdinal) ?? 0) + emittedPageCount);
 			}
 			if (usedDirectOutput) logger.info(`atlas: Direct output for single image package "${pkg.getName()}".`);
 			logger.info(`atlas: Packed ${inputs.length} images into ${totalPageCount} atlas(es) for package "${pkg.getName()}".`);
@@ -1428,6 +1407,171 @@ function buildBranchAtlasGroups(doc, inputs, options) {
 		inputs: groups.get(branchName) ?? []
 	}));
 }
+function reserveAutoPageStart(branchPageOffsets, branchOrdinal, reservedPageIndexes) {
+	let pageIndex = branchPageOffsets.get(branchOrdinal) ?? 0;
+	while (branchOrdinal === 0 && reservedPageIndexes.has(pageIndex)) pageIndex += 1;
+	return pageIndex;
+}
+async function emitPagedAtlasGroup(doc, pkg, allResources, inputs, context) {
+	if (inputs.length === 0) return 0;
+	const pages = packAtlasPages(inputs, context.options, context.forceSinglePage === true);
+	if (pages.length === 0) return 0;
+	for (let pageOffset = 0; pageOffset < pages.length; pageOffset += 1) {
+		const page = pages[pageOffset];
+		const pageIndex = context.pageStart + pageOffset;
+		const atlasNode = doc.createAtlas(`atlas${resolveAtlasIndex(context.branchOrdinal, pageIndex)}`);
+		atlasNode.setIndex(resolveAtlasIndex(context.branchOrdinal, pageIndex));
+		atlasNode.setFile(context.fileNameAt(pageIndex));
+		atlasNode.setWidth(page.width);
+		atlasNode.setHeight(page.height);
+		pkg.addAtlas(atlasNode);
+		attachSpritesToAtlas(doc, allResources, inputs, page.outputRects, atlasNode);
+		await writeAtlasPageImage(pkg, inputs, page, atlasNode.getFile(), context.encoder, context.options, context.logger);
+	}
+	return pages.length;
+}
+async function emitStandaloneAtlasGroup(doc, pkg, group, context) {
+	if (group.inputs.length === 0) return 0;
+	const pages = packAtlasPages(group.inputs, context.options, true, group.sizeMode === "npot" ? {
+		powerOfTwo: false,
+		multipleOfFour: false,
+		square: false
+	} : group.sizeMode === "multipleOf4" ? {
+		powerOfTwo: false,
+		multipleOfFour: true,
+		square: false
+	} : void 0);
+	if (pages.length === 0) return 0;
+	for (let pageOffset = 0; pageOffset < pages.length; pageOffset += 1) {
+		const page = pages[pageOffset];
+		const baseFileName = resolveStandaloneAtlasOutputFileName(pkg, group.resource, group.branchName);
+		const atlasFileName = pages.length <= 1 ? baseFileName : insertFileNameSuffix(baseFileName, `_${pageOffset}`);
+		const atlasIndex = context.atlasIndexStart + pageOffset;
+		const atlasNode = doc.createAtlas(`atlas${resolveAtlasIndex(group.branchOrdinal, atlasIndex)}`);
+		atlasNode.setIndex(resolveAtlasIndex(group.branchOrdinal, atlasIndex));
+		atlasNode.setFile(atlasFileName);
+		const standaloneSize = resolveStandaloneAtlasSize(page.width, page.height, group.sizeMode, context.options);
+		atlasNode.setWidth(standaloneSize.width);
+		atlasNode.setHeight(standaloneSize.height);
+		pkg.addAtlas(atlasNode);
+		attachSpritesToAtlas(doc, [], group.inputs, page.outputRects, atlasNode);
+		await writeAtlasPageImage(pkg, group.inputs, {
+			...page,
+			width: standaloneSize.width,
+			height: standaloneSize.height
+		}, atlasFileName, context.encoder, context.options, context.logger);
+	}
+	return pages.length;
+}
+function packAtlasPages(inputs, options, forceSinglePage, sizeOverrides) {
+	const hasDuplicatePadding = inputs.some((input) => {
+		return isImageResource$1(input.resource) && input.resource.getDuplicatePadding?.() === true;
+	});
+	return new MaxRectsPackerCompat({
+		pot: sizeOverrides?.powerOfTwo ?? options.powerOfTwo,
+		mof: sizeOverrides?.multipleOfFour ?? !options.powerOfTwo,
+		padding: options.padding,
+		rotation: options.allowRotation,
+		minWidth: 16,
+		minHeight: 16,
+		maxWidth: options.maxSize,
+		maxHeight: options.maxSize,
+		square: sizeOverrides?.square ?? options.square,
+		fast: options.fast,
+		edgePadding: false,
+		duplicatePadding: hasDuplicatePadding,
+		multiPage: forceSinglePage ? false : options.multiPage,
+		preserveInputOrderOnTie: options.preserveInputOrderOnTie
+	}).pack(inputs.map((input, index) => inputToCompatRect(input, index))) ?? [];
+}
+function attachSpritesToAtlas(doc, allResources, inputs, outputRects, atlasNode) {
+	for (const packedRect of outputRects) {
+		const input = inputs[packedRect.index];
+		if (!input) continue;
+		const packedSize = resolvePackedRectSize(input, packedRect.width, packedRect.height, packedRect.rotated);
+		const sprite = doc.createSprite();
+		sprite.setItemId(input.id);
+		sprite.setRectX(packedRect.x);
+		sprite.setRectY(packedRect.y);
+		sprite.setRectWidth(packedSize.width);
+		sprite.setRectHeight(packedSize.height);
+		sprite.setRotated(packedRect.rotated);
+		sprite.setOffsetX(input.offsetX);
+		sprite.setOffsetY(input.offsetY);
+		sprite.setOriginalWidth(input.originalWidth);
+		sprite.setOriginalHeight(input.originalHeight);
+		sprite.setAtlas(atlasNode);
+		atlasNode.addSprite(sprite);
+	}
+	for (const resource of allResources) {
+		if (!isFontResource$1(resource)) continue;
+		const alias = resource.getExtras()?._fontSpriteAlias;
+		if (!alias) continue;
+		const imageSprite = outputRects.find((result) => inputs[result.index]?.id === alias.textureId);
+		if (!imageSprite) continue;
+		const imageInput = inputs[imageSprite.index];
+		const fontSprite = doc.createSprite();
+		fontSprite.setItemId(alias.fontId);
+		fontSprite.setRectX(imageSprite.x);
+		fontSprite.setRectY(imageSprite.y);
+		fontSprite.setRectWidth(imageSprite.width);
+		fontSprite.setRectHeight(imageSprite.height);
+		fontSprite.setRotated(imageSprite.rotated);
+		if (imageInput) {
+			fontSprite.setOffsetX(imageInput.offsetX);
+			fontSprite.setOffsetY(imageInput.offsetY);
+			fontSprite.setOriginalWidth(imageInput.originalWidth);
+			fontSprite.setOriginalHeight(imageInput.originalHeight);
+		}
+		fontSprite.setAtlas(atlasNode);
+		atlasNode.addSprite(fontSprite);
+	}
+}
+async function writeAtlasPageImage(pkg, inputs, page, atlasFileName, encoder, options, logger) {
+	if (!encoder || !options.outputPath) return;
+	if (options.mkdir) await options.mkdir(options.outputPath);
+	const compositeInputs = [];
+	for (const packedRect of page.outputRects) {
+		const input = inputs[packedRect.index];
+		if (!input) continue;
+		if (packedRect.width <= 0 || packedRect.height <= 0 || input.width <= 0 || input.height <= 0) continue;
+		try {
+			let imageBuffer;
+			if (input.trimBuffer) {
+				imageBuffer = input.trimBuffer;
+				if (imageBuffer.length === 0) continue;
+			} else if (input.rasterizedBuffer) imageBuffer = input.rasterizedBuffer;
+			else {
+				if (!isImageResource$1(input.resource)) {
+					logger.warn(`atlas: Non-image input "${input.id}" is missing inline buffer, skipping compositing.`);
+					continue;
+				}
+				imageBuffer = await encoder(_resolveImagePath(input.resource, pkg, options.basePath)).toBuffer();
+			}
+			if (packedRect.rotated) imageBuffer = await encoder(imageBuffer).rotate(270).toBuffer();
+			compositeInputs.push({
+				input: imageBuffer,
+				left: packedRect.x,
+				top: packedRect.y
+			});
+		} catch {
+			logger.warn(`atlas: Could not read image "${input.id}" for compositing.`);
+		}
+	}
+	const outputFile = `${options.outputPath}/${atlasFileName}`;
+	await encoder({ create: {
+		width: page.width,
+		height: page.height,
+		channels: 4,
+		background: {
+			r: 0,
+			g: 0,
+			b: 0,
+			alpha: 0
+		}
+	} }).composite(compositeInputs).toFile(outputFile);
+	logger.info(`atlas: Generated ${atlasFileName} (${page.width}x${page.height}, ${page.outputRects.length} sprites)`);
+}
 function inputToCompatRect(input, index) {
 	const duplicatePadding = isImageResource$1(input.resource) && input.resource.getDuplicatePadding?.() === true;
 	return {
@@ -1542,14 +1686,47 @@ function resolveAtlasOutputFileName(pkg, pageIndex, branchName) {
 	const suffix = branchName ? `_${branchName}` : "";
 	return `${pkg.getPublishName() || pkg.getName()}_atlas${pageIndex}${suffix}.png`;
 }
+function resolveStandaloneAtlasOutputFileName(pkg, resource, branchName) {
+	const baseName = `${pkg.getPublishName() || pkg.getName()}_atlas_${getPublishedItemId(resource)}`;
+	const suffix = branchName ? `_${branchName}` : "";
+	if (isImageResource$1(resource)) return `${baseName}${suffix}${extname$1(resolveImageFileName$1(resource)) || ".png"}`;
+	return `${baseName}${suffix}.png`;
+}
+function resolveStandaloneAtlasSize(width, height, sizeMode, options) {
+	if (sizeMode === "npot") return {
+		width,
+		height
+	};
+	if (sizeMode === "multipleOf4") return {
+		width: roundUpToMultiple(width, 4),
+		height: roundUpToMultiple(height, 4)
+	};
+	return resolveDirectOutputAtlasSize(width, height, options);
+}
 function resolveImageFileName$1(resource) {
 	const extras = resource.getExtras();
 	return resource.getFileName() || extras._fileName || resource.getName();
 }
+function extname$1(fileName) {
+	const normalized = fileName.replace(/\\/g, "/");
+	const lastSlash = normalized.lastIndexOf("/");
+	const lastDot = normalized.lastIndexOf(".");
+	if (lastDot <= lastSlash) return "";
+	return normalized.slice(lastDot);
+}
+function insertFileNameSuffix(fileName, suffix) {
+	const extension = extname$1(fileName);
+	if (!extension) return `${fileName}${suffix}`;
+	return `${fileName.slice(0, -extension.length)}${suffix}${extension}`;
+}
 function nextPow2(value) {
 	if (value <= 1) return 1;
 	return 2 ** Math.ceil(Math.log2(value));
 }
+function roundUpToMultiple(value, base) {
+	if (value <= 0) return 0;
+	return Math.ceil(value / base) * base;
+}
 function sortResourcesByOrder(resources, orderMap, inputOrderMap) {
 	const ordered = [...resources];
 	ordered.sort((left, right) => {
@@ -1565,14 +1742,71 @@ function sortResourcesByOrder(resources, orderMap, inputOrderMap) {
 	});
 	return ordered;
 }
+function getResourceTextureSetMode(resource) {
+	if (isImageResource$1(resource)) return parseTextureSetMode(resource.getTextureSetMode?.());
+	return parseTextureSetMode(resource.getTextureSetMode?.());
+}
+function groupStandaloneInputs(doc, inputs, options) {
+	const autoInputs = [];
+	const fixedInputsByPage = /* @__PURE__ */ new Map();
+	const standaloneGroups = /* @__PURE__ */ new Map();
+	const reservedPageIndexes = /* @__PURE__ */ new Set();
+	const discoveredBranchNames = [...new Set(inputs.map((input) => getInputBranchName(input)).filter((branchName) => !!branchName))];
+	const orderedBranchNames = doc.getRoot().listBranches().filter((branchName) => discoveredBranchNames.includes(branchName));
+	for (const branchName of discoveredBranchNames) if (!orderedBranchNames.includes(branchName)) orderedBranchNames.push(branchName);
+	const branchOrdinalByName = /* @__PURE__ */ new Map();
+	branchOrdinalByName.set("", 0);
+	if (options.separatedAtlasForBranch) {
+		let ordinal = 1;
+		for (const branchName of orderedBranchNames) branchOrdinalByName.set(branchName, ordinal++);
+	} else for (const branchName of orderedBranchNames) branchOrdinalByName.set(branchName, 0);
+	for (const input of inputs) {
+		const branchName = getInputBranchName(input);
+		const branchOrdinal = branchOrdinalByName.get(branchName) ?? 0;
+		const mode = getResourceTextureSetMode(input.resource);
+		if (mode.kind === "standalone") {
+			const key = `${branchName}\u0000${getPublishedItemId(input.resource)}`;
+			const existing = standaloneGroups.get(key);
+			if (existing) existing.inputs.push(input);
+			else standaloneGroups.set(key, {
+				resource: input.resource,
+				branchName,
+				branchOrdinal,
+				sizeMode: mode.sizeMode,
+				inputs: [input]
+			});
+			continue;
+		}
+		if (mode.kind === "page") {
+			reservedPageIndexes.add(mode.pageIndex);
+			const key = `${branchName}\u0000${mode.pageIndex}`;
+			const existing = fixedInputsByPage.get(key);
+			if (existing) existing.inputs.push(input);
+			else fixedInputsByPage.set(key, {
+				pageIndex: mode.pageIndex,
+				branchName,
+				branchOrdinal,
+				inputs: [input]
+			});
+			continue;
+		}
+		autoInputs.push(input);
+	}
+	return {
+		autoInputs,
+		fixedPageGroups: [...fixedInputsByPage.values()].sort((left, right) => left.branchOrdinal - right.branchOrdinal || left.pageIndex - right.pageIndex),
+		standaloneGroups: [...standaloneGroups.values()].sort((left, right) => left.branchOrdinal - right.branchOrdinal || getPublishedItemId(left.resource).localeCompare(getPublishedItemId(right.resource))),
+		reservedPageIndexes
+	};
+}
 /**
 * Trim transparent edges from an image using sharp.
 * Returns the trimmed buffer, dimensions, and offsets.
 * Falls back to the original image if trim fails (e.g. no alpha channel, no transparent edges).
 */
-async function _trimImage(encoder, filePath, originalWidth, originalHeight) {
+async function _trimImage(encoder, input, originalWidth, originalHeight) {
 	try {
-		const trimResult = await encoder(filePath).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
+		const trimResult = await encoder(input).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
 		if (!isResolvedBuffer(trimResult)) throw new Error("atlas: encoder raw alpha trim did not return resolved metadata.");
 		const { data, info } = trimResult;
 		const width = info.width;
@@ -1601,7 +1835,7 @@ async function _trimImage(encoder, filePath, originalWidth, originalHeight) {
 		const trimmedWidth = maxX - minX + 1;
 		const trimmedHeight = maxY - minY + 1;
 		return {
-			buffer: await encoder(filePath).extract({
+			buffer: await encoder(input).extract({
 				left: minX,
 				top: minY,
 				width: trimmedWidth,
@@ -1616,7 +1850,7 @@ async function _trimImage(encoder, filePath, originalWidth, originalHeight) {
 		};
 	} catch {
 		return {
-			buffer: await encoder(filePath).png().toBuffer(),
+			buffer: await encoder(input).png().toBuffer(),
 			width: originalWidth,
 			height: originalHeight,
 			offsetX: 0,
@@ -1640,7 +1874,10 @@ function _resolveImagePath(resource, pkg, basePath) {
 async function _collectImage(resource, pkg, inputs, encoder, options, doTrim, logger) {
 	let origW = resource.getWidth() ?? 0;
 	let origH = resource.getHeight() ?? 0;
+	const declaredWidth = origW;
+	const declaredHeight = origH;
 	let sourceHasAlpha = false;
+	let rasterizedBuffer;
 	if (encoder && options.basePath) {
 		const filePath = _resolveImagePath(resource, pkg, options.basePath);
 		try {
@@ -1652,6 +1889,10 @@ async function _collectImage(resource, pkg, inputs, encoder, options, doTrim, lo
 				resource.setHeight(origH);
 			}
 			sourceHasAlpha = metadata.hasAlpha === true || metadata.channels === 4;
+			if (/\.svg$/i.test(resolveImageFileName$1(resource)) && declaredWidth > 0 && declaredHeight > 0) {
+				rasterizedBuffer = await encoder(filePath).resize(declaredWidth, declaredHeight, { fit: "fill" }).png().toBuffer();
+				sourceHasAlpha = true;
+			}
 		} catch {
 			if (origW === 0 || origH === 0) {
 				logger.warn(`atlas: Could not read image "${filePath}", skipping.`);
@@ -1665,7 +1906,7 @@ async function _collectImage(resource, pkg, inputs, encoder, options, doTrim, lo
 	if (doTrim && sourceHasAlpha && options.basePath && encoder) {
 		const filePath = _resolveImagePath(resource, pkg, options.basePath);
 		try {
-			const trimResult = await _trimImage(encoder, filePath, origW, origH);
+			const trimResult = await _trimImage(encoder, rasterizedBuffer ?? filePath, origW, origH);
 			packW = trimResult.width;
 			packH = trimResult.height;
 			offX = trimResult.offsetX;
@@ -1685,6 +1926,7 @@ async function _collectImage(resource, pkg, inputs, encoder, options, doTrim, lo
 		offsetY: offY,
 		resource,
 		trimBuffer: trimBuf,
+		rasterizedBuffer,
 		sourceKind: "image"
 	});
 }
@@ -2117,6 +2359,62 @@ const FGUI_TYPESCRIPT_BINDER_TEMPLATE = `{{generatedMark}}
 }
 `;
 //#endregion
+//#region src/plugins/loader.ts
+const importNative = new Function("id", "return import(id)");
+async function loadPlugins(doc, pluginsDir) {
+	if (!pluginsDir) return [];
+	const fs = await importNative("node:fs/promises");
+	const path = await importNative("node:path");
+	let entries;
+	try {
+		entries = await fs.readdir(pluginsDir, { withFileTypes: true });
+	} catch {
+		return [];
+	}
+	const plugins = [];
+	for (const entry of entries) {
+		if (!entry.isDirectory()) continue;
+		const pluginDir = path.join(pluginsDir, entry.name);
+		try {
+			const manifest = await readPluginManifest(fs, path, pluginDir);
+			if (!manifest) continue;
+			const plugin = await loadPlugin(resolvePluginMain(path, pluginDir, manifest));
+			plugins.push({
+				name: manifest.name,
+				plugin
+			});
+		} catch (error) {
+			doc.getLogger().warn(`publish: Plugin "${entry.name}" was skipped: ${formatPluginError(error)}`);
+		}
+	}
+	return plugins;
+}
+function formatPluginError(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+async function readPluginManifest(fs, path, pluginDir) {
+	const manifestPath = path.join(pluginDir, "package.json");
+	const content = await fs.readFile(manifestPath, "utf-8");
+	const manifest = JSON.parse(content);
+	if (!manifest.name) throw new Error(`Codegen plugin at ${pluginDir} is missing package.json name.`);
+	if (!manifest.main) throw new Error(`Codegen plugin "${manifest.name}" is missing package.json main.`);
+	return manifest;
+}
+function resolvePluginMain(path, pluginDir, manifest) {
+	const mainPath = path.resolve(pluginDir, manifest.main);
+	const relative = path.relative(pluginDir, mainPath);
+	if (relative.startsWith("..") || path.isAbsolute(relative)) throw new Error(`Codegen plugin "${manifest.name}" main must resolve inside its plugin directory.`);
+	return mainPath;
+}
+async function loadPlugin(mainPath) {
+	const mod = await createJiti(import.meta.url).import(mainPath);
+	const defaultExport = mod.default;
+	return isObject(defaultExport) ? defaultExport : mod;
+}
+function isObject(value) {
+	return value !== null && typeof value === "object";
+}
+//#endregion
 //#region src/codegen.ts
 const AUTO_GENERATED_CODE_MARK = "/** This is an automatically generated class by FairyGUI. Please do not modify it. **/";
 const DEFAULT_CLASS_NAME_PREFIX = "UI_";
@@ -2152,6 +2450,18 @@ async function publishCodeGeneration(doc, options) {
 	const logger = doc.getLogger();
 	const settings = resolveCodeGenerationSettings(doc);
 	if (!settings.allowGenCode) return;
+	const plugins = options.plugins?.filter((plugin) => typeof plugin.plugin.genCode === "function") ?? [];
+	if (plugins.length > 0) {
+		let handled = false;
+		for (const plugin of plugins) try {
+			await plugin.plugin.genCode(doc, settings, options);
+			handled = true;
+			logger.info(`publish: Generated code using plugin "${plugin.name}"`);
+		} catch (error) {
+			logger.warn(`publish: Code generation plugin "${plugin.name}" failed: ${formatPluginError(error)}`);
+		}
+		if (handled) return;
+	}
 	for (const pkg of options.packages) {
 		if (!pkg.getGenCode()) continue;
 		const plan = resolvePackageCodegenPlan(pkg, settings, options);
@@ -2250,9 +2560,9 @@ async function cleanupGeneratedFiles(directory, fs, extension = ".cs") {
 	}
 }
 function buildCodegenClasses(doc, pkg, plan) {
-	const exportedComponents = pkg.listComponents().filter((component) => component.getExported()).sort((left, right) => left.getId().localeCompare(right.getId()));
+	const codegenComponents = pkg.listComponents().sort((left, right) => left.getId().localeCompare(right.getId()));
 	const generatedById = /* @__PURE__ */ new Map();
-	for (const component of exportedComponents) {
+	for (const component of codegenComponents) {
 		const encodedClassName = `${plan.settings.classNamePrefix}${normalizeTypeName(component.getName()) || "Component"}`;
 		generatedById.set(component.getId(), {
 			classId: component.getId(),
@@ -2265,7 +2575,13 @@ function buildCodegenClasses(doc, pkg, plan) {
 			members: []
 		});
 	}
-	for (const component of exportedComponents) {
+	for (const component of codegenComponents) {
+		const classInfo = generatedById.get(component.getId());
+		if (!classInfo) continue;
+		classInfo.members = buildCodegenMembers(doc, pkg, component, plan, generatedById);
+	}
+	for (const [componentId, classInfo] of generatedById) if (classInfo.members.every((member) => member.ignored)) generatedById.delete(componentId);
+	for (const component of codegenComponents) {
 		const classInfo = generatedById.get(component.getId());
 		if (!classInfo) continue;
 		classInfo.members = buildCodegenMembers(doc, pkg, component, plan, generatedById);
@@ -2279,7 +2595,12 @@ function buildCodegenMembers(doc, pkg, component, plan, generatedById) {
 	let childIndex = 0;
 	let transitionIndex = 0;
 	for (const controller of component.listControllers()) members.push(createMember(ownerType, "controller", "Controller", controller.getName(), controllerIndex++, plan));
-	for (const child of component.listChildren()) members.push(createMember(ownerType, "child", resolveChildType(doc, pkg, child, generatedById), child.getName(), childIndex++, plan));
+	for (const child of component.listChildren()) {
+		if (!isRuntimeChild(child)) continue;
+		const index = childIndex++;
+		const resolvedChild = resolveChildType(doc, pkg, child, generatedById);
+		members.push(createMember(ownerType, "child", resolvedChild.type, child.getName(), index, plan, resolvedChild.referencedComponent));
+	}
 	for (const transition of component.listTransitions()) members.push(createMember(ownerType, "transition", "Transition", transition.getName(), transitionIndex++, plan));
 	const usedNames = /* @__PURE__ */ new Map();
 	for (const member of members) {
@@ -2291,7 +2612,10 @@ function buildCodegenMembers(doc, pkg, component, plan, generatedById) {
 	}
 	return members;
 }
-function createMember(ownerType, kind, type, originalName, index, plan) {
+function isRuntimeChild(child) {
+	return child.propertyType !== "GGroup" || child.getAdvanced?.() === true;
+}
+function createMember(ownerType, kind, type, originalName, index, plan, referencedComponent) {
 	const ignored = plan.settings.ignoreNoname && isDefaultMemberName(ownerType, kind, originalName);
 	return {
 		index,
@@ -2299,30 +2623,41 @@ function createMember(ownerType, kind, type, originalName, index, plan) {
 		name: applyMemberNamePrefix(originalName, plan.settings.memberNamePrefix),
 		originalName,
 		type,
-		ignored
+		ignored,
+		referencedComponent
 	};
 }
 function resolveChildType(doc, pkg, child, generatedById) {
 	const src = child.getSrc?.();
 	if (src) {
-		const localResource = resolveChildSourceComponent(doc, pkg, src);
-		if (localResource) return generatedById.get(localResource.getId())?.encodedClassName ?? resolveComponentBaseType(localResource);
+		let referencedComponent = null;
+		if (src.startsWith("ui://")) {
+			const rest = src.slice(5);
+			const pkgId = rest.slice(0, 8);
+			const resourceId = rest.slice(8);
+			const targetPackage = doc.getRoot().listPackages().find((candidate) => candidate.getId() === pkgId);
+			const targetResource = targetPackage?.getResourceById(resourceId);
+			if (targetPackage && targetResource?.propertyType === "Component") referencedComponent = {
+				component: targetResource,
+				package: targetPackage
+			};
+		} else {
+			const packageId = child.getPackageId?.();
+			const targetPackage = packageId ? doc.getRoot().listPackages().find((candidate) => candidate.getId() === packageId) : pkg;
+			const targetResource = targetPackage?.getResourceById(src);
+			if (targetPackage && targetResource?.propertyType === "Component") referencedComponent = {
+				component: targetResource,
+				package: targetPackage
+			};
+		}
+		if (referencedComponent) return {
+			type: (referencedComponent.package === pkg ? generatedById.get(referencedComponent.component.getId()) : void 0)?.encodedClassName ?? resolveComponentBaseType(referencedComponent.component),
+			referencedComponent
+		};
 	}
 	const instanceExtType = child.getInstanceExtType?.();
-	if (instanceExtType) return `G${instanceExtType}`;
-	return child.propertyType;
-}
-function resolveChildSourceComponent(doc, pkg, src) {
-	if (!src) return null;
-	if (src.startsWith("ui://")) {
-		const rest = src.slice(5);
-		const pkgId = rest.slice(0, 8);
-		const resourceId = rest.slice(8);
-		const targetResource = doc.getRoot().listPackages().find((candidate) => candidate.getId() === pkgId)?.getResourceById(resourceId);
-		return targetResource?.propertyType === "Component" ? targetResource : null;
-	}
-	const localResource = pkg.getResourceById(src);
-	return localResource?.propertyType === "Component" ? localResource : null;
+	if (instanceExtType) return { type: `G${instanceExtType}` };
+	return { type: child.propertyType };
 }
 function resolveComponentBaseType(component) {
 	const extensionType = component.getExtensionType();
@@ -2393,21 +2728,21 @@ function renderFguiTypescriptMemberAssignment(member, getMemberByName, variant)
 	return getMemberByName ? `\t\tthis.${member.name} = <${translatedType}><any>(this.getChild("${escapeTypeScriptString(member.originalName)}"));` : `\t\tthis.${member.name} = <${translatedType}><any>(this.getChildAt(${member.index}));`;
 }
 function resolveCodePath(codePath, basePath, fs) {
-	if (isAbsolutePath(codePath)) return trimTrailingSlashes$1(codePath);
+	if (isAbsolutePath(codePath)) return trimTrailingSlashes$2(codePath);
 	const projectBasePath = resolveProjectBasePath(basePath);
-	return projectBasePath ? trimTrailingSlashes$1(fs.join(projectBasePath, codePath)) : trimTrailingSlashes$1(codePath);
+	return projectBasePath ? trimTrailingSlashes$2(fs.join(projectBasePath, codePath)) : trimTrailingSlashes$2(codePath);
 }
 function resolveProjectBasePath(basePath) {
 	if (!basePath) return "";
-	const normalized = trimTrailingSlashes$1(basePath);
+	const normalized = trimTrailingSlashes$2(basePath);
 	const assetsMatch = normalized.match(/^(.*)[/\\]assets(?:_[^/\\]+)?$/i);
 	if (assetsMatch?.[1]) return assetsMatch[1];
 	return dirname$2(normalized);
 }
 function dirname$2(filePath) {
-	return trimTrailingSlashes$1(filePath).match(/^(.*)[/\\][^/\\]+$/)?.[1] ?? "";
+	return trimTrailingSlashes$2(filePath).match(/^(.*)[/\\][^/\\]+$/)?.[1] ?? "";
 }
-function trimTrailingSlashes$1(value) {
+function trimTrailingSlashes$2(value) {
 	return value.replace(/[/\\]+$/, "");
 }
 function isAbsolutePath(value) {
@@ -2416,9 +2751,15 @@ function isAbsolutePath(value) {
 function isDefaultMemberName(ownerType, kind, name) {
 	if (kind === "controller") return (ownerType === "GButton" || ownerType === "GComboBox") && name === "button";
 	if (kind === "transition") return false;
-	if (ownerType === "GButton" || ownerType === "GLabel" || ownerType === "GComboBox") return name === "title" || name === "icon";
-	if (ownerType === "GProgressBar") return name === "bar" || name === "bar_v" || name === "title" || name === "ani";
-	if (ownerType === "GSlider") return name === "bar" || name === "bar_v" || name === "grip" || name === "title" || name === "ani";
+	if (ownerType === "GButton" || ownerType === "GLabel" || ownerType === "GComboBox") {
+		if (name === "title" || name === "icon") return true;
+	}
+	if (ownerType === "GProgressBar") {
+		if (name === "bar" || name === "bar_v" || name === "title" || name === "ani") return true;
+	}
+	if (ownerType === "GSlider") {
+		if (name === "bar" || name === "bar_v" || name === "grip" || name === "title" || name === "ani") return true;
+	}
 	return /^n\d+(?:_.*)?$/i.test(name);
 }
 function applyMemberNamePrefix(name, prefix) {
@@ -2707,11 +3048,11 @@ function inferPackageName(fileName) {
 	if (/\.fui$/i.test(fileName)) return fileName.replace(/\.fui$/i, "");
 	return fileName.replace(/\.bin$/i, "");
 }
-function trimTrailingSlashes(value) {
+function trimTrailingSlashes$1(value) {
 	return value.replace(/[/\\]+$/, "");
 }
 function normalizeComparablePath(value) {
-	const normalized = trimTrailingSlashes(value).replace(/\\/g, "/");
+	const normalized = trimTrailingSlashes$1(value).replace(/\\/g, "/");
 	const driveMatch = normalized.match(/^([a-z]:)(?:\/(.*))?$/i);
 	const drivePrefix = driveMatch?.[1].toLowerCase() ?? "";
 	const remainder = driveMatch ? driveMatch[2] ?? "" : normalized;
@@ -2731,14 +3072,14 @@ function normalizeComparablePath(value) {
 	return (drivePrefix ? `${drivePrefix}/${joined}`.replace(/\/$/, "") : hasRoot ? `/${joined}`.replace(/\/$/, "") : joined || ".").toLowerCase();
 }
 function dirname$1(filePath) {
-	return trimTrailingSlashes(filePath).match(/^(.*)[/\\][^/\\]+$/)?.[1] ?? "";
+	return trimTrailingSlashes$1(filePath).match(/^(.*)[/\\][^/\\]+$/)?.[1] ?? "";
 }
 function basename(filePath) {
-	return trimTrailingSlashes(filePath).match(/([^/\\]+)$/)?.[1] ?? "";
+	return trimTrailingSlashes$1(filePath).match(/([^/\\]+)$/)?.[1] ?? "";
 }
 function resolveOutputProjectPath(output, fs) {
 	if (/\.fairy$/i.test(output)) return output;
-	const normalizedOutput = trimTrailingSlashes(output);
+	const normalizedOutput = trimTrailingSlashes$1(output);
 	const projectName = basename(normalizedOutput) || "Restored";
 	return fs.join(normalizedOutput, `${projectName}.fairy`);
 }
@@ -2784,7 +3125,7 @@ async function prepareRestoreOutputDir(inputDir, outputDir, outputProjectPath, f
 	await fs.mkdir(outputDir);
 }
 async function restore(options) {
-	const sourceDir = trimTrailingSlashes(options.inputDir);
+	const sourceDir = trimTrailingSlashes$1(options.inputDir);
 	const outputIsProjectFile = /\.fairy$/i.test(options.output);
 	const outputProjectPath = resolveOutputProjectPath(options.output, options.fs);
 	await prepareRestoreOutputDir(sourceDir, dirname$1(outputProjectPath) || ".", outputProjectPath, options.fs, options.force === true, outputIsProjectFile);
@@ -2926,16 +3267,23 @@ var RestoreWorkflow = class {
 	async _ensureLooseImageResource(doc, pkg, owner, sourceDir, fileName) {
 		const resources = pkg.listResources();
 		const existing = this._findResourceByFile(resources, owner, "ImageResource", fileName);
-		if (existing) return existing;
 		const sourcePath = await this._resolveLooseSourceFile(pkg, sourceDir, fileName);
-		if (!sourcePath) return null;
+		if (!sourcePath) return existing ?? null;
+		if (existing) {
+			existing.setExtras?.({
+				...existing.getExtras?.() ?? {},
+				_publishedFile: fileBaseName(sourcePath),
+				_restoreAsLooseImage: true
+			});
+			return existing;
+		}
 		const resource = doc.createImageResource(stripExtension(fileName));
 		resource.setId(generateId()).setPath(owner.getPath?.() ?? "/").setBranch(owner.getBranch?.() ?? "").setBranchItemIds(owner.getBranchItemIds?.() ?? []).setExported(false).setFileName(fileName);
 		resource.setExtras?.({
 			...resource.getExtras?.() ?? {},
 			_publishedFile: fileBaseName(sourcePath),
 			_suppressPackageSize: true,
-			_syntheticLooseImage: true
+			_restoreAsLooseImage: true
 		});
 		pkg.addResource(resource);
 		return resource;
@@ -3109,13 +3457,13 @@ var RestoreWorkflow = class {
 	}
 	async _copyLooseResources(pkg, options, warnings) {
 		for (const resource of pkg.listResources()) {
-			const syntheticLooseImage = resource.getExtras?.()?._syntheticLooseImage === true;
+			const restoreAsLooseImage = resource.getExtras?.()?._restoreAsLooseImage === true;
 			if (![
 				"SoundResource",
 				"MiscResource",
 				"SpineResource",
 				"DragonBonesResource"
-			].includes(resource.propertyType) && !syntheticLooseImage) continue;
+			].includes(resource.propertyType) && !restoreAsLooseImage) continue;
 			const fileName = resourceFileName(resource);
 			if (!fileName) continue;
 			const sourcePath = await this._resolveSourceFile(options.sourceDir, this._sourceFileCandidates(pkg, resourcePublishedFileName(resource), fileName));
@@ -3285,6 +3633,26 @@ var RestoreWorkflow = class {
 };
 //#endregion
 //#region src/publish.ts
+async function runPublishPluginHook(plugins, hook, doc, options) {
+	const logger = doc.getLogger();
+	for (const plugin of plugins) {
+		const fn = plugin.plugin[hook];
+		if (typeof fn !== "function") continue;
+		try {
+			await fn(doc, options);
+		} catch (error) {
+			logger.warn(`publish: Plugin "${plugin.name}" ${hook} failed: ${formatPluginError(error)}`);
+		}
+	}
+}
+function resolvePublishPluginsDir(doc, options) {
+	const fs = options.fs;
+	const projectDir = doc.getProjectDir?.() ?? "";
+	if (projectDir) return fs?.join ? fs.join(projectDir, "plugins") : `${projectDir.replace(/[/\\]+$/, "")}/plugins`;
+	const projectBasePath = resolveProjectBasePath(options.basePath);
+	if (!projectBasePath) return "";
+	return fs?.join ? fs.join(projectBasePath, "plugins") : `${projectBasePath.replace(/[/\\]+$/, "")}/plugins`;
+}
 const UNITY_PROJECT_TYPE = ProjectType.Unity;
 const COCOS_CREATOR_PROJECT_TYPE = ProjectType.CocosCreator;
 function resolveDefaultPublishFileExtension(projectType, publishSettings) {
@@ -3334,6 +3702,19 @@ function resolvePublishOptions(doc, overrides = {}) {
 		atlas: atlasOptions
 	};
 }
+function trimTrailingSlashes(value) {
+	return value.replace(/[/\\]+$/, "");
+}
+function isAbsolutePathLike(value) {
+	return /^(?:[a-zA-Z]:[/\\]|[/\\]{1,2})/u.test(value);
+}
+function joinPathSegments(left, right) {
+	const normalizedLeft = trimTrailingSlashes(left);
+	const normalizedRight = right.replace(/^[/\\]+/, "");
+	if (!normalizedLeft) return normalizedRight;
+	if (!normalizedRight) return normalizedLeft;
+	return `${normalizedLeft}${normalizedLeft.includes("\\") ? "\\" : "/"}${normalizedRight}`;
+}
 function dirname(filePath) {
 	return filePath.replace(/[/\\]+$/, "").match(/^(.*)[/\\][^/\\]+$/)?.[1] ?? "";
 }
@@ -3364,6 +3745,9 @@ function isImageResource(resource) {
 function isMovieClipResource(resource) {
 	return resource.propertyType === "MovieClipResource";
 }
+function isHighResolutionResource(resource) {
+	return isImageResource(resource) || isMovieClipResource(resource);
+}
 function isMiscResource(resource) {
 	return resource.propertyType === "MiscResource";
 }
@@ -3446,13 +3830,14 @@ function extname(fileName) {
 	if (lastDot <= lastSlash) return "";
 	return normalized.slice(lastDot);
 }
-function resolvePublishedMiscFileName(resource) {
+function resolvePublishedMiscFileName(resource, projectType) {
 	const file = resource.getFile();
+	if (projectType !== UNITY_PROJECT_TYPE) return file;
 	if (file.toLowerCase().endsWith(".atlas")) return `${file}.txt`;
 	return file;
 }
-function resolvePublishedSkeletonFileName(resource) {
-	if (isSpineResource(resource) && resource.getFile().toLowerCase().endsWith(".skel")) return `${resource.getFile()}.bytes`;
+function resolvePublishedSkeletonFileName(resource, projectType) {
+	if (projectType === UNITY_PROJECT_TYPE && isSpineResource(resource) && resource.getFile().toLowerCase().endsWith(".skel")) return `${resource.getFile()}.bytes`;
 	return resource.getFile();
 }
 function setPublishedFileExtra(resource, fileName) {
@@ -3484,6 +3869,70 @@ function getBranchName(resource) {
 function buildBranchResourceKey(resource) {
 	return `${resource.propertyType}|${resource.getPath() ?? ""}|${resource.getName() ?? ""}`;
 }
+const HIGH_RESOLUTION_LEVELS = [
+	{
+		scale: 2,
+		bit: 1,
+		slot: 0
+	},
+	{
+		scale: 3,
+		bit: 2,
+		slot: 1
+	},
+	{
+		scale: 4,
+		bit: 4,
+		slot: 2
+	}
+];
+function buildHighResolutionResourceKey(resource, name = resource.getName()) {
+	return `${resource.propertyType}|${resource.getBranch?.() ?? ""}|${resource.getPath() ?? ""}|${name}`;
+}
+function isHighResolutionVariantName(name) {
+	return /@(?:2|3|4)x(?:\.[^./\\]+)?$/iu.test(name);
+}
+function appendHighResolutionScaleToName(name, scale) {
+	const extensionIndex = name.lastIndexOf(".");
+	if (extensionIndex > 0) return `${name.slice(0, extensionIndex)}@${scale}x${name.slice(extensionIndex)}`;
+	return `${name}@${scale}x`;
+}
+function trimTrailingMissingHighResolutionIds(ids) {
+	while (ids.length > 0 && !ids[ids.length - 1]) ids.pop();
+	return ids;
+}
+function collectHighResolutionItemIds(resources, publishedResourceIds, includeHighResolution) {
+	const result = /* @__PURE__ */ new Map();
+	if (includeHighResolution <= 0) return result;
+	const highResolutionResourceByKey = /* @__PURE__ */ new Map();
+	for (const resource of resources) {
+		if (!isHighResolutionResource(resource)) continue;
+		highResolutionResourceByKey.set(buildHighResolutionResourceKey(resource), resource);
+	}
+	for (const resource of resources) {
+		if (!isHighResolutionResource(resource)) continue;
+		if (!publishedResourceIds.has(resource.getId())) continue;
+		if (isHighResolutionVariantName(resource.getName())) continue;
+		const ids = [];
+		for (const level of HIGH_RESOLUTION_LEVELS) {
+			if ((includeHighResolution & level.bit) === 0) {
+				ids[level.slot] = null;
+				continue;
+			}
+			const highResolutionResource = highResolutionResourceByKey.get(buildHighResolutionResourceKey(resource, appendHighResolutionScaleToName(resource.getName(), level.scale)));
+			if (!highResolutionResource) {
+				ids[level.slot] = null;
+				continue;
+			}
+			const highResolutionId = highResolutionResource.getId();
+			publishedResourceIds.add(highResolutionId);
+			ids[level.slot] = highResolutionId;
+		}
+		trimTrailingMissingHighResolutionIds(ids);
+		if (ids.length > 0) result.set(resource.getId(), ids);
+	}
+	return result;
+}
 function collectPackagePublishContext(pkg, options) {
 	const pkgId = pkg.getId();
 	const resources = pkg.listResources();
@@ -3491,6 +3940,24 @@ function collectPackagePublishContext(pkg, options) {
 	const referencedIds = /* @__PURE__ */ new Set();
 	const pixelHitTestImageIds = /* @__PURE__ */ new Set();
 	const spriteItemIds = /* @__PURE__ */ new Set();
+	const collectExportedResourceIds = (sourceResources, sourcePublishedResourceIds) => {
+		const exportedResourceIds = new Set(sourcePublishedResourceIds);
+		const resourcesById = new Map(sourceResources.map((resource) => [resource.getId(), resource]));
+		let changed = true;
+		while (changed) {
+			changed = false;
+			for (const resourceId of [...exportedResourceIds]) {
+				const resource = resourcesById.get(resourceId);
+				if (!resource || !isSkeletonResource(resource)) continue;
+				for (const requiredId of resource.getRequireIds()) {
+					if (!requiredId || exportedResourceIds.has(requiredId)) continue;
+					exportedResourceIds.add(requiredId);
+					changed = true;
+				}
+			}
+		}
+		return exportedResourceIds;
+	};
 	for (const atlas of pkg.listAtlases()) for (const sprite of atlas.listSprites()) spriteItemIds.add(sprite.getItemId());
 	for (const resource of resources) {
 		if (!isComponentResource(resource)) continue;
@@ -3517,6 +3984,7 @@ function collectPackagePublishContext(pkg, options) {
 				child.getSelectedIcon?.(),
 				child.getDropdown?.(),
 				child.getSound?.(),
+				child.getInstanceSound?.(),
 				child.getInstanceIcon?.(),
 				child.getInstanceSelectedIcon?.(),
 				child.getVtScrollBarRes?.(),
@@ -3574,19 +4042,8 @@ function collectPackagePublishContext(pkg, options) {
 		}
 		if (resource.getExported() || referencedIds.has(resourceId)) publishedResourceIds.add(resourceId);
 	}
-	let changed = true;
-	while (changed) {
-		changed = false;
-		for (const resource of resources) {
-			if (!isSkeletonResource(resource)) continue;
-			if (!publishedResourceIds.has(resource.getId())) continue;
-			for (const requiredId of resource.getRequireIds()) {
-				if (!requiredId || publishedResourceIds.has(requiredId)) continue;
-				publishedResourceIds.add(requiredId);
-				changed = true;
-			}
-		}
-	}
+	for (const resourceId of collectExportedResourceIds(resources, publishedResourceIds)) publishedResourceIds.add(resourceId);
+	const highResolutionItemIds = collectHighResolutionItemIds(resources, publishedResourceIds, options.includeHighResolution);
 	if (!options.includeBranches) {
 		const mainByKey = /* @__PURE__ */ new Map();
 		const activeBranchByKey = /* @__PURE__ */ new Map();
@@ -3634,7 +4091,9 @@ function collectPackagePublishContext(pkg, options) {
 		return {
 			referencedIds,
 			publishedResourceIds,
+			exportedResourceIds: collectExportedResourceIds(resources, publishedResourceIds),
 			pixelHitTestImageIds,
+			highResolutionItemIds,
 			effectiveResourceIds,
 			includeBranches: false
 		};
@@ -3642,7 +4101,9 @@ function collectPackagePublishContext(pkg, options) {
 	return {
 		referencedIds,
 		publishedResourceIds,
+		exportedResourceIds: collectExportedResourceIds(resources, publishedResourceIds),
 		pixelHitTestImageIds,
+		highResolutionItemIds,
 		effectiveResourceIds: new Map([...publishedResourceIds].map((resourceId) => [resourceId, resourceId])),
 		includeBranches: true
 	};
@@ -3691,28 +4152,36 @@ async function applyPixelHitTests(pkg, imageIds, basePath, encoder) {
 	}
 }
 async function annotatePackagePublishArtifacts(pkg, basePath, encoder, options) {
-	const { publishedResourceIds, pixelHitTestImageIds, effectiveResourceIds, includeBranches } = collectPackagePublishContext(pkg, options);
-	for (const resource of pkg.listResources()) setPublishedIdExtra(resource, effectiveResourceIds.get(resource.getId()) ?? null);
+	const { publishedResourceIds, exportedResourceIds, pixelHitTestImageIds, highResolutionItemIds, effectiveResourceIds, includeBranches } = collectPackagePublishContext(pkg, options);
+	for (const resource of pkg.listResources()) {
+		setPublishedIdExtra(resource, effectiveResourceIds.get(resource.getId()) ?? null);
+		if (isHighResolutionResource(resource)) resource.setHighResolutionItemIds(highResolutionItemIds.get(resource.getId()) ?? []);
+	}
 	await applyPixelHitTests(pkg, pixelHitTestImageIds, basePath, encoder);
 	const extras = pkg.getExtras() ?? {};
 	pkg.setExtras({
 		...extras,
 		publishedResourceIds: [...publishedResourceIds].sort((a, b) => a.localeCompare(b)),
+		exportedResourceIds: [...exportedResourceIds].sort((a, b) => a.localeCompare(b)),
 		publishedIncludeBranches: includeBranches,
 		publishedEffectiveResourceIds: Object.fromEntries(effectiveResourceIds)
 	});
 	for (const resource of pkg.listResources()) {
 		if (isMiscResource(resource)) {
-			setPublishedFileExtra(resource, resolvePublishedMiscFileName(resource));
+			setPublishedFileExtra(resource, resolvePublishedMiscFileName(resource, options.projectType));
 			continue;
 		}
-		if (isSkeletonResource(resource)) setPublishedFileExtra(resource, resolvePublishedSkeletonFileName(resource));
+		if (isSkeletonResource(resource)) setPublishedFileExtra(resource, resolvePublishedSkeletonFileName(resource, options.projectType));
 	}
 }
 function getAnnotatedPublishedResourceIds(pkg) {
 	const extras = pkg.getExtras() ?? {};
 	return new Set(extras.publishedResourceIds ?? []);
 }
+function getAnnotatedExportedResourceIds(pkg) {
+	const extras = pkg.getExtras() ?? {};
+	return new Set(extras.exportedResourceIds ?? []);
+}
 function getPublishedSkeletonDependencyImageIds(pkg, publishedResourceIds) {
 	const imageIds = /* @__PURE__ */ new Set();
 	const resourcesById = new Map(pkg.listResources().map((resource) => [resource.getId(), resource]));
@@ -3751,18 +4220,18 @@ async function exportPackageSounds(pkg, outputDir, basePath, fs, readFileRaw, lo
 	}
 }
 async function exportPackageExternalResources(pkg, outputDir, basePath, fs, readFileRaw, logger) {
-	const publishedResourceIds = getAnnotatedPublishedResourceIds(pkg);
-	const skeletonDependencyImageIds = getPublishedSkeletonDependencyImageIds(pkg, publishedResourceIds);
-	if (publishedResourceIds.size === 0) return;
+	const exportedResourceIds = getAnnotatedExportedResourceIds(pkg);
+	const skeletonDependencyImageIds = getPublishedSkeletonDependencyImageIds(pkg, exportedResourceIds);
+	if (exportedResourceIds.size === 0) return;
 	if (!basePath || !readFileRaw) {
 		if (pkg.listResources().some((resource) => {
-			return (isMiscResource(resource) || isSkeletonResource(resource)) && publishedResourceIds.has(resource.getId()) || skeletonDependencyImageIds.has(resource.getId());
+			return (isMiscResource(resource) || isSkeletonResource(resource)) && exportedResourceIds.has(resource.getId()) || skeletonDependencyImageIds.has(resource.getId());
 		})) logger.warn(`publish: External resources in package "${pkg.getName()}" were not exported because basePath/readFileRaw is unavailable.`);
 		return;
 	}
 	for (const resource of pkg.listResources()) {
 		const resourceId = resource.getId();
-		const isSkeletonExternal = publishedResourceIds.has(resourceId) && (isMiscResource(resource) || isSkeletonResource(resource));
+		const isSkeletonExternal = exportedResourceIds.has(resourceId) && (isMiscResource(resource) || isSkeletonResource(resource));
 		const isSkeletonImageDependency = skeletonDependencyImageIds.has(resourceId) && isImageResource(resource);
 		if (!isSkeletonExternal && !isSkeletonImageDependency) continue;
 		let sourcePath;
@@ -3808,16 +4277,102 @@ async function exportPackageExternalResources(pkg, outputDir, basePath, fs, read
 */
 function publish(options) {
 	return createTransform("publish", async (doc) => {
+		const resolveConfiguredOutputPath = (value, projectBasePath) => {
+			const trimmed = value?.trim();
+			if (!trimmed) return void 0;
+			if (isAbsolutePathLike(trimmed) || !projectBasePath) return trimTrailingSlashes(trimmed);
+			return trimTrailingSlashes(options.fs ? options.fs.join(projectBasePath, trimmed) : joinPathSegments(projectBasePath, trimmed));
+		};
+		const resolveProjectPublishConfig = () => {
+			const publishSettings = (doc.getRoot().getSettings?.() ?? {}).publish ?? {};
+			const resolved = resolvePublishOptions(doc, {
+				compressed: options.compressed,
+				fileExtension: options.fileExtension,
+				packages: options.packages,
+				atlas: options.atlas
+			});
+			const includeBranches = (publishSettings.branchProcessing ?? 0) === 0;
+			return {
+				...resolved,
+				projectType: doc.getRoot().getProjectType(),
+				includeBranches,
+				activeBranch: includeBranches ? "" : options.branch ?? "",
+				includeHighResolution: publishSettings.includeHighResolution ?? 0,
+				separatedAtlasForBranch: includeBranches && publishSettings.seperatedAtlasForBranch === true,
+				globalOutputPath: publishSettings.path?.trim() ?? "",
+				globalBranchOutputPath: publishSettings.branchPath?.trim() ?? ""
+			};
+		};
+		const resolvePackagePublishPlan = (pkg, config, projectBasePath) => {
+			let outputDir;
+			if (options.output) outputDir = trimTrailingSlashes(options.output);
+			else {
+				const candidates = [];
+				if (!config.includeBranches && config.activeBranch) candidates.push(pkg.getPublishBranchPath(), config.globalBranchOutputPath);
+				candidates.push(pkg.getPublishPath(), config.globalOutputPath);
+				for (const candidate of candidates) {
+					const resolved = resolveConfiguredOutputPath(candidate, projectBasePath);
+					if (!resolved) continue;
+					outputDir = resolved;
+					break;
+				}
+			}
+			const publishName = pkg.getPublishName() || pkg.getName();
+			return {
+				pkg,
+				outputDir,
+				publishName,
+				fileName: resolvePublishFileName(publishName, config.fileExtension),
+				compressed: config.compressed,
+				fileExtension: config.fileExtension,
+				includeBranches: config.includeBranches,
+				activeBranch: config.activeBranch,
+				includeHighResolution: config.includeHighResolution,
+				separatedAtlasForBranch: config.separatedAtlasForBranch,
+				atlas: config.atlas
+			};
+		};
+		const createNoopPublishFs = () => ({
+			async writeFileRaw() {},
+			async mkdir() {},
+			join(...paths) {
+				return paths.join("/");
+			}
+		});
+		const publishPackage = async (plan, writerFs, packageIndex) => {
+			const atlasRuntimeOptions = resolvePublishAtlasRuntimeOptions(plan.fileExtension);
+			await atlas({
+				...plan.atlas,
+				...options.atlas ?? {},
+				separatedAtlasForBranch: plan.separatedAtlasForBranch,
+				encoder: options.encoder,
+				basePath: options.basePath,
+				outputPath: options.fs ? plan.outputDir : void 0,
+				mkdir: options.fs ? options.fs.mkdir : void 0,
+				readFileRaw: options.atlas?.readFileRaw ?? options.fs?.readFileRaw,
+				packages: [plan.pkg.getName()],
+				...atlasRuntimeOptions
+			})(doc);
+			if (!options.fs) return;
+			if (!plan.outputDir) throw new Error("publish: no output directory resolved. Provide --output, or configure global publish.path / package publishPath.");
+			await options.fs.mkdir(plan.outputDir);
+			const filePath = options.fs.join(plan.outputDir, plan.fileName);
+			const bwOptions = {
+				compressed: plan.compressed,
+				packageIndex
+			};
+			await new BinaryWriter(writerFs).write(doc, filePath, bwOptions);
+			await exportPackageSounds(plan.pkg, plan.outputDir, options.basePath, options.fs, options.atlas?.readFileRaw ?? options.fs.readFileRaw, logger);
+			await exportPackageExternalResources(plan.pkg, plan.outputDir, options.basePath, options.fs, options.atlas?.readFileRaw ?? options.fs.readFileRaw, logger);
+			logger.info(`publish: Written ${plan.fileName}`);
+		};
 		const root = doc.getRoot();
 		const logger = doc.getLogger();
-		const publishSettings = (root.getSettings?.() ?? {}).publish ?? {};
-		const resolved = resolvePublishOptions(doc, {
-			compressed: options.compressed,
-			fileExtension: options.fileExtension,
-			packages: options.packages,
-			atlas: options.atlas
-		});
-		const ext = resolved.fileExtension;
+		const projectBasePath = resolveProjectBasePath(options.basePath) || doc.getProjectDir?.() || "";
+		const pluginsDir = resolvePublishPluginsDir(doc, options);
+		const plugins = pluginsDir ? await loadPlugins(doc, pluginsDir) : [];
+		await runPublishPluginHook(plugins, "onPublishStart", doc, options);
+		const resolved = resolveProjectPublishConfig();
 		let allPackages = root.listPackages();
 		if (resolved.packages && resolved.packages.length > 0) {
 			const names = new Set(resolved.packages);
@@ -3825,57 +4380,42 @@ function publish(options) {
 		}
 		if (allPackages.length === 0) {
 			logger.warn("publish: No packages to publish.");
+			await runPublishPluginHook(plugins, "onPublishEnd", doc, options);
 			return;
 		}
-		const includeBranches = (publishSettings.branchProcessing ?? 0) === 0;
-		const activeBranch = includeBranches ? "" : options.branch ?? "";
-		const atlasRuntimeOptions = resolvePublishAtlasRuntimeOptions(ext);
 		const allDocPackages = root.listPackages();
 		const pkgMap = /* @__PURE__ */ new Map();
 		for (const p of allDocPackages) pkgMap.set(p.getId(), p);
 		for (const pkg of allPackages) {
-			_computeDependencies(pkg, pkgMap);
+			_computeDependencies(doc, pkg, pkgMap);
 			await annotatePackagePublishArtifacts(pkg, options.basePath, options.encoder, {
-				includeBranches,
-				activeBranch
+				projectType: resolved.projectType,
+				includeBranches: resolved.includeBranches,
+				activeBranch: resolved.activeBranch,
+				includeHighResolution: resolved.includeHighResolution
 			});
 		}
-		await atlas({
-			...resolved.atlas,
-			...options.atlas ?? {},
-			separatedAtlasForBranch: includeBranches && publishSettings.seperatedAtlasForBranch === true,
-			encoder: options.encoder,
-			basePath: options.basePath,
-			outputPath: options.fs ? options.output : void 0,
-			mkdir: options.fs ? options.fs.mkdir : void 0,
-			readFileRaw: options.atlas?.readFileRaw ?? options.fs?.readFileRaw,
-			...atlasRuntimeOptions
-		})(doc);
+		const plans = allPackages.map((pkg) => resolvePackagePublishPlan(pkg, resolved, projectBasePath));
 		if (!options.fs) {
 			logger.info(`publish: No fs provided — layout computed for ${allPackages.length} package(s), skipping file output.`);
+			const noopWriterFs = toBinaryWriterFileSystem(createNoopPublishFs());
+			for (const plan of plans) await publishPackage(plan, noopWriterFs, allDocPackages.indexOf(plan.pkg));
+			await runPublishPluginHook(plugins, "onPublishEnd", doc, options);
 			return;
 		}
-		await options.fs.mkdir(options.output);
+		const unresolvedPlan = plans.find((plan) => !plan.outputDir);
+		if (unresolvedPlan) throw new Error(`publish: no output directory resolved for package "${unresolvedPlan.pkg.getName()}". Provide --output, or configure global publish.path / package publishPath.`);
 		const writerFs = toBinaryWriterFileSystem(options.fs);
-		for (const pkg of allPackages) {
-			const pkgIndex = allDocPackages.indexOf(pkg);
-			const fileName = resolvePublishFileName(pkg.getPublishName() || pkg.getName(), ext);
-			const filePath = options.fs.join(options.output, fileName);
-			const bwOptions = {
-				compressed: resolved.compressed,
-				packageIndex: pkgIndex
-			};
-			await new BinaryWriter(writerFs).write(doc, filePath, bwOptions);
-			await exportPackageSounds(pkg, options.output, options.basePath, options.fs, options.atlas?.readFileRaw ?? options.fs.readFileRaw, logger);
-			await exportPackageExternalResources(pkg, options.output, options.basePath, options.fs, options.atlas?.readFileRaw ?? options.fs.readFileRaw, logger);
-			logger.info(`publish: Written ${fileName}`);
-		}
+		for (const plan of plans) await publishPackage(plan, writerFs, allDocPackages.indexOf(plan.pkg));
 		await publishCodeGeneration(doc, {
 			basePath: options.basePath,
 			fs: options.fs,
-			packages: allPackages
+			packages: allPackages,
+			plugins
 		});
-		logger.info(`publish: Published ${allPackages.length} package(s) to ${options.output}`);
+		const publishedTargets = [...new Set(plans.map((plan) => plan.outputDir).filter((value) => Boolean(value)))];
+		logger.info(publishedTargets.length > 0 ? `publish: Published ${allPackages.length} package(s) to ${publishedTargets.join(", ")}` : `publish: Published ${allPackages.length} package(s)`);
+		await runPublishPluginHook(plugins, "onPublishEnd", doc, options);
 	});
 }
 /**
@@ -3883,25 +4423,104 @@ function publish(options) {
 * The editor only adds dependencies for packages referenced via bitmap font URLs.
 * @internal
 */
-function _computeDependencies(pkg, pkgMap) {
+function _computeDependencies(doc, pkg, pkgMap) {
 	const referencedPkgIds = /* @__PURE__ */ new Set();
-	function scanFontUrl(font) {
-		if (!font) return;
-		const fontStr = Array.isArray(font) ? font[0] : String(font);
-		if (typeof fontStr !== "string" || !fontStr.startsWith("ui://")) return;
-		const rest = fontStr.slice(5);
-		if (rest.length >= 8) {
-			const depPkgId = rest.slice(0, 8);
-			if (depPkgId !== pkg.getId()) referencedPkgIds.add(depPkgId);
+	const pkgId = pkg.getId();
+	const packageOrder = new Map(doc.getRoot().listPackages().map((entry, index) => [entry.getId(), index]));
+	const addDependencyPackageId = (dependencyPkgId) => {
+		const normalized = dependencyPkgId?.trim() ?? "";
+		if (!normalized || normalized === pkgId) return;
+		referencedPkgIds.add(normalized);
+	};
+	const extractPackageIdFromUiUrl = (value) => {
+		if (!value.startsWith("ui://")) return null;
+		const rest = value.slice(5);
+		if (!rest) return null;
+		const slashIndex = rest.indexOf("/");
+		if (slashIndex >= 0) return rest.slice(0, slashIndex) || null;
+		if (rest.length >= 8) return rest.slice(0, 8);
+		return null;
+	};
+	const addDependencyPackageIdFromUiValue = (value) => {
+		if (!value || typeof value !== "string") return;
+		addDependencyPackageId(extractPackageIdFromUiUrl(value));
+	};
+	const addDependencyPackageIdsFromText = (value) => {
+		if (!value || typeof value !== "string") return;
+		const matches = value.matchAll(/ui:\/\/([0-9a-z]{8})/giu);
+		for (const match of matches) addDependencyPackageId(match[1] ?? "");
+	};
+	const addDependencyPackageIdsFromUnknown = (value) => {
+		if (Array.isArray(value)) {
+			for (const entry of value) addDependencyPackageIdsFromUnknown(entry);
+			return;
 		}
-	}
+		if (typeof value === "string") {
+			addDependencyPackageIdFromUiValue(value);
+			addDependencyPackageIdsFromText(value);
+		}
+	};
+	const addDependencyFontRef = (value) => {
+		if (Array.isArray(value)) {
+			for (const entry of value) addDependencyPackageIdFromUiValue(entry);
+			return;
+		}
+		addDependencyPackageIdFromUiValue(value ?? void 0);
+	};
 	for (const res of pkg.listResources()) {
 		if (res.propertyType !== "Component") continue;
-		for (const child of res.listChildren?.() ?? []) scanFontUrl(child.getFont?.());
+		const component = res;
+		for (const child of component.listChildren?.() ?? []) {
+			addDependencyPackageId(child.getPackageId?.());
+			addDependencyFontRef(child.getFont?.());
+			addDependencyPackageIdsFromText(child.getText?.());
+			for (const ref of [
+				child.getUrl?.(),
+				child.getDefaultItem?.(),
+				child.getIcon?.(),
+				child.getSelectedIcon?.(),
+				child.getDropdown?.(),
+				child.getSound?.(),
+				child.getInstanceSound?.(),
+				child.getInstanceIcon?.(),
+				child.getInstanceSelectedIcon?.(),
+				child.getVtScrollBarRes?.(),
+				child.getHzScrollBarRes?.(),
+				child.getHeaderRes?.(),
+				child.getFooterRes?.()
+			]) addDependencyPackageIdFromUiValue(ref);
+			for (const item of child.getInstanceComboItems?.() ?? []) addDependencyPackageIdFromUiValue(item.icon ?? void 0);
+			for (const item of child.getListItems?.() ?? []) {
+				addDependencyPackageIdFromUiValue(item.icon ?? void 0);
+				addDependencyPackageIdFromUiValue(item.url ?? void 0);
+			}
+			for (const gear of child.listGears?.() ?? []) {
+				addDependencyPackageIdsFromUnknown(gear.getValues?.());
+				addDependencyPackageIdsFromUnknown(gear.getDefaultValue?.());
+			}
+		}
+		addDependencyFontRef(component.getFont?.());
+		for (const ref of [
+			component.getDropdown?.(),
+			component.getHeaderRes?.(),
+			component.getFooterRes?.(),
+			component.getVtScrollBarRes?.(),
+			component.getHzScrollBarRes?.(),
+			component.getSound?.()
+		]) addDependencyPackageIdFromUiValue(ref);
+		for (const transition of component.listTransitions?.() ?? []) for (const item of transition.listItems?.() ?? []) {
+			addDependencyPackageIdsFromUnknown(item.getStartValue?.());
+			addDependencyPackageIdsFromUnknown(item.getEndValue?.());
+		}
 	}
 	for (const dep of pkg.listDependencies()) pkg.removeDependency(dep);
 	if (referencedPkgIds.size > 0) {
-		const sortedIds = [...referencedPkgIds].sort((a, b) => a.localeCompare(b));
+		const sortedIds = [...referencedPkgIds].sort((a, b) => {
+			const orderA = packageOrder.get(a) ?? Number.MAX_SAFE_INTEGER;
+			const orderB = packageOrder.get(b) ?? Number.MAX_SAFE_INTEGER;
+			if (orderA !== orderB) return orderA - orderB;
+			return a.localeCompare(b);
+		});
 		for (const refId of sortedIds) {
 			const depPkg = pkgMap.get(refId);
 			if (depPkg) pkg.addDependency(depPkg);
@@ -3909,37 +4528,4 @@ function _computeDependencies(pkg, pkgMap) {
 	}
 }
 //#endregion
-//#region src/uam-transaction.ts
-function mapTransactionErrorStage(error) {
-	switch (error.code) {
-		case "transaction_unsupported": return "preflight";
-		case "invalid_uam": return "preflight";
-		case "execution_failure": return error.opIndex === void 0 && error.issues !== void 0 ? "postflight" : "execution";
-		case "selector_ambiguity": return error.opIndex === void 0 ? "preflight" : "execution";
-	}
-}
-function applyUamTransactionApp(input) {
-	try {
-		return {
-			ok: true,
-			project: applyUamTransaction(input.project, input.operations)
-		};
-	} catch (error) {
-		if (error instanceof UamTransactionError) return {
-			ok: false,
-			error: {
-				code: error.code,
-				stage: mapTransactionErrorStage(error),
-				message: error.message,
-				opIndex: error.opIndex,
-				opId: error.opId,
-				opKind: error.opKind,
-				selector: error.selector,
-				issues: error.issues
-			}
-		};
-		throw error;
-	}
-}
-//#endregion
-export { AUTO_GENERATED_CODE_MARK, ValidationSeverity, applyUamTransactionApp, atlas, createTransform, inspect, prune, publish, publishCodeGeneration, rename, resolvePublishOptions, restore, validate };
+export { AUTO_GENERATED_CODE_MARK, ValidationSeverity, applyUamTransactionApp, atlas, buildCodegenClasses, createTransform, decodeText, encodeText, inspect, prune, publish, publishCodeGeneration, rename, resolvePackageCodegenPlan, resolvePublishOptions, restore, validate };