@openfairygui/functions 0.2.0-alpha.13 → 0.2.0-alpha.15

package/dist/{publish-Bl-GK9kt.js → publish-DsPK0SJ1.js}

@@ -751,7 +751,8 @@ const ATLAS_DEFAULTS = {
 	preserveInputOrderOnTie: false,
 	directSingleImageOutput: false,
 	extractAlpha: false,
-	separatedAtlasForBranch: false
+	separatedAtlasForBranch: false,
+	strictOutput: false
 };
 function getPublishedItemId(resource) {
 	return (resource.getExtras() ?? {})._publishedId ?? resource.getId();
@@ -908,8 +909,9 @@ function atlas(_options = {}) {
 		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 publishedResourceIds = pkg.getExtras()?.publishedResourceIds;
+			const selectedPublishIds = new Set(publishedResourceIds);
+			const allResources = publishedResourceIds !== void 0 && (options.strictOutput || 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])));
@@ -998,6 +1000,7 @@ function atlas(_options = {}) {
 				await _collectFontTexture(doc, res, pkg, options);
 			}
 			if (inputs.length === 0) continue;
+			if (options.strictOutput && (!encoder || !options.basePath || !options.outputPath)) throw new Error(`atlas: Package "${pkg.getName()}" requires encoder, basePath, and outputPath for complete raster output.`);
 			let totalPageCount = 0;
 			let usedDirectOutput = false;
 			const { autoInputs, fixedPageGroups, standaloneGroups, reservedPageIndexes } = groupStandaloneInputs(doc, inputs, options);
@@ -1095,7 +1098,7 @@ function reserveAutoPageStart(branchPageOffsets, branchOrdinal, reservedPageInde
 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;
+	assertPackedInputCoverage(pages, inputs.length, `package "${pkg.getName()}"`);
 	for (let pageOffset = 0; pageOffset < pages.length; pageOffset += 1) {
 		const page = pages[pageOffset];
 		const pageIndex = context.pageStart + pageOffset;
@@ -1121,7 +1124,7 @@ async function emitStandaloneAtlasGroup(doc, pkg, group, context) {
 		multipleOfFour: true,
 		square: false
 	} : void 0);
-	if (pages.length === 0) return 0;
+	assertPackedInputCoverage(pages, group.inputs.length, `standalone texture in package "${pkg.getName()}"`);
 	for (let pageOffset = 0; pageOffset < pages.length; pageOffset += 1) {
 		const page = pages[pageOffset];
 		const baseFileName = resolveStandaloneAtlasOutputFileName(pkg, group.resource, group.branchName);
@@ -1164,6 +1167,12 @@ function packAtlasPages(inputs, options, forceSinglePage, sizeOverrides) {
 		preserveInputOrderOnTie: options.preserveInputOrderOnTie
 	}).pack(inputs.map((input, index) => inputToCompatRect(input, index))) ?? [];
 }
+function assertPackedInputCoverage(pages, inputCount, label) {
+	const packedIndexes = /* @__PURE__ */ new Set();
+	for (const page of pages) for (const outputRect of page.outputRects) packedIndexes.add(outputRect.index);
+	const hasEveryInput = Array.from({ length: inputCount }, (_, index) => packedIndexes.has(index)).every(Boolean);
+	if (packedIndexes.size !== inputCount || !hasEveryInput) throw new Error(`atlas: Could not pack every input for ${label}.`);
+}
 function attachSpritesToAtlas(doc, allResources, inputs, outputRects, atlasNode) {
 	for (const packedRect of outputRects) {
 		const input = inputs[packedRect.index];
@@ -1223,7 +1232,9 @@ async function writeAtlasPageImage(pkg, inputs, page, atlasFileName, encoder, op
 			} 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.`);
+					const message = `atlas: Non-image input "${input.id}" is missing inline buffer.`;
+					if (options.strictOutput) throw new Error(message);
+					logger.warn(`${message} Skipping compositing.`);
 					continue;
 				}
 				imageBuffer = await encoder(_resolveImagePath(input.resource, pkg, options.basePath)).toBuffer();
@@ -1235,7 +1246,9 @@ async function writeAtlasPageImage(pkg, inputs, page, atlasFileName, encoder, op
 				top: packedRect.y
 			});
 		} catch {
-			logger.warn(`atlas: Could not read image "${input.id}" for compositing.`);
+			const message = `atlas: Could not read image "${input.id}" for compositing.`;
+			if (options.strictOutput) throw new Error(message);
+			logger.warn(message);
 		}
 	}
 	const outputFile = `${options.outputPath}/${atlasFileName}`;
@@ -1352,7 +1365,9 @@ async function emitDirectImageOutput(doc, pkg, input, encoder, options, logger,
 			}]).png().toFile(outputFile);
 		}
 	} catch {
-		logger.warn(`atlas: Could not write direct-output atlas "${atlasFileName}".`);
+		const message = `atlas: Could not write direct-output atlas "${atlasFileName}".`;
+		if (options.strictOutput) throw new Error(message);
+		logger.warn(message);
 	}
 }
 function getInputBranchName(input) {
@@ -1578,6 +1593,7 @@ async function _collectImage(resource, pkg, inputs, encoder, options, doTrim, lo
 				sourceHasAlpha = true;
 			}
 		} catch {
+			if (options.strictOutput) throw new Error(`atlas: Could not read image "${filePath}".`);
 			if (origW === 0 || origH === 0) {
 				logger.warn(`atlas: Could not read image "${filePath}", skipping.`);
 				return;
@@ -1616,7 +1632,11 @@ async function _collectImage(resource, pkg, inputs, encoder, options, doTrim, lo
 }
 /** Collect MovieClip frame textures from a .jta file into the inputs array. */
 async function _collectMovieClipFrames(doc, resource, pkg, inputs, encoder, options, logger) {
-	if (!options.basePath || !options.readFileRaw) return;
+	if (!options.basePath || !options.readFileRaw) {
+		if (options.strictOutput) throw new Error(`atlas: MovieClip "${resource.getId()}" requires basePath and readFileRaw for complete raster output.`);
+		return;
+	}
+	if (!encoder && options.strictOutput) throw new Error(`atlas: MovieClip "${resource.getId()}" requires an encoder for complete raster output.`);
 	const mcId = resource.getId();
 	const mcName = resource.getName() + ".jta";
 	const mcPath = resource.getPath() ?? "/";
@@ -1639,7 +1659,7 @@ async function _collectMovieClipFrames(doc, resource, pkg, inputs, encoder, opti
 				const exportFrameIndex = firstFrameIndexByTextureIndex.get(textureIndex);
 				if (exportFrameIndex === void 0) continue;
 				const itemId = `${mcId}_${exportFrameIndex}`;
-				const input = await _createMovieClipFrameInput(jta.frames[textureIndex], itemId, resource, encoder);
+				const input = await _createMovieClipFrameInput(jta.frames[textureIndex], itemId, resource, encoder, options.strictOutput);
 				if (!input) continue;
 				inputs.push(input);
 				spriteIdByTextureIndex.set(textureIndex, itemId);
@@ -1653,7 +1673,7 @@ async function _collectMovieClipFrames(doc, resource, pkg, inputs, encoder, opti
 			}
 		} else for (let frameIndex = 0; frameIndex < jta.frames.length; frameIndex += 1) {
 			const itemId = `${mcId}_${frameIndex}`;
-			const input = await _createMovieClipFrameInput(jta.frames[frameIndex], itemId, resource, encoder);
+			const input = await _createMovieClipFrameInput(jta.frames[frameIndex], itemId, resource, encoder, options.strictOutput);
 			if (!input) continue;
 			inputs.push(input);
 			const frame = doc.createMovieFrame(itemId);
@@ -1665,10 +1685,12 @@ async function _collectMovieClipFrames(doc, resource, pkg, inputs, encoder, opti
 			resource.setHeight(jta.meta?.height ?? 0);
 		}
 	} catch {
-		logger.warn(`atlas: Could not parse MovieClip "${filePath}", skipping frames.`);
+		const message = `atlas: Could not parse MovieClip "${filePath}".`;
+		if (options.strictOutput) throw new Error(message);
+		logger.warn(`${message} Skipping frames.`);
 	}
 }
-async function _createMovieClipFrameInput(buffer, itemId, resource, encoder) {
+async function _createMovieClipFrameInput(buffer, itemId, resource, encoder, strictOutput) {
 	if (!encoder || buffer.length === 0) return null;
 	try {
 		const meta = await encoder(buffer).metadata();
@@ -1688,6 +1710,7 @@ async function _createMovieClipFrameInput(buffer, itemId, resource, encoder) {
 			sourceKind: "movieclip-frame"
 		};
 	} catch {
+		if (strictOutput) throw new Error(`atlas: Could not decode MovieClip frame "${itemId}".`);
 		return null;
 	}
 }
@@ -3000,13 +3023,13 @@ function getPublishedSkeletonDependencyImageIds(pkg, publishedResourceIds) {
 	}
 	return imageIds;
 }
-async function exportPackageSounds(pkg, outputDir, basePath, fs, readFileRaw, logger) {
+async function exportPackageSounds(pkg, outputDir, basePath, fs, readFileRaw) {
 	const publishedResourceIds = getAnnotatedPublishedResourceIds(pkg);
 	if (publishedResourceIds.size === 0) return;
 	if (!basePath || !readFileRaw) {
 		if (pkg.listResources().some((resource) => {
 			return isSoundResource(resource) && publishedResourceIds.has(resource.getId());
-		})) logger.warn(`publish: Sound resources in package "${pkg.getName()}" were not exported because basePath/readFileRaw is unavailable.`);
+		})) throw new Error(`publish: Sound resources in package "${pkg.getName()}" require basePath and readFileRaw for output.`);
 		return;
 	}
 	for (const resource of pkg.listResources()) {
@@ -3019,18 +3042,18 @@ async function exportPackageSounds(pkg, outputDir, basePath, fs, readFileRaw, lo
 			const data = await readFileRaw(sourcePath);
 			await fs.writeFileRaw(targetPath, data);
 		} catch {
-			logger.warn(`publish: Could not export sound "${resource.getId()}" from package "${pkg.getName()}".`);
+			throw new Error(`publish: Could not export sound "${resource.getId()}" from package "${pkg.getName()}".`);
 		}
 	}
 }
-async function exportPackageExternalResources(pkg, outputDir, basePath, fs, readFileRaw, logger) {
+async function exportPackageExternalResources(pkg, outputDir, basePath, fs, readFileRaw) {
 	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)) && 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.`);
+		})) throw new Error(`publish: External resources in package "${pkg.getName()}" require basePath and readFileRaw for output.`);
 		return;
 	}
 	for (const resource of pkg.listResources()) {
@@ -3052,7 +3075,7 @@ async function exportPackageExternalResources(pkg, outputDir, basePath, fs, read
 			const data = await readFileRaw(sourcePath);
 			await fs.writeFileRaw(targetPath, data);
 		} catch {
-			logger.warn(`publish: Could not export external resource "${resource.getId()}" from package "${pkg.getName()}".`);
+			throw new Error(`publish: Could not export external resource "${resource.getId()}" from package "${pkg.getName()}".`);
 		}
 	}
 }
@@ -3068,18 +3091,17 @@ async function exportPackageExternalResources(pkg, outputDir, basePath, fs, read
 * `publishNode()` or `publishBrowser()` through their dedicated entries.
 *
 * ```ts
-* import sharp from 'sharp';
-* const io = new NodeIO();
-* const doc = await io.readProject('./project.fairy');
+* import { NodeIO } from '@openfairygui/core/node';
+* import { publishNode } from '@openfairygui/functions/node';
+* const doc = await new NodeIO().readProject('./project.fairy');
 *
-* await doc.transform(publish({
+* await publishNode({
+*   document: doc,
 *   output: './release/',
 *   compressed: true,
-*   encoder: sharp,
-*   basePath: './assets/',
+*   assetsPath: './assets/',
 *   fileExtension: 'bytes',
-*   fs: io.createFileSystem(),
-* }));
+* });
 * ```
 */
 function publish(options) {
@@ -3147,6 +3169,12 @@ function publish(options) {
 			}
 		});
 		const publishPackage = async (plan, writerFs, packageIndex) => {
+			if (options.fs && !plan.outputDir) throw new Error("publish: no output directory resolved. Provide --output, or configure global publish.path / package publishPath.");
+			if (options.fs) {
+				await options.fs.mkdir(plan.outputDir);
+				await exportPackageSounds(plan.pkg, plan.outputDir, options.basePath, options.fs, options.atlas?.readFileRaw ?? options.fs.readFileRaw);
+				await exportPackageExternalResources(plan.pkg, plan.outputDir, options.basePath, options.fs, options.atlas?.readFileRaw ?? options.fs.readFileRaw);
+			}
 			const atlasRuntimeOptions = resolvePublishAtlasRuntimeOptions(plan.fileExtension);
 			await atlas({
 				...plan.atlas,
@@ -3157,20 +3185,17 @@ function publish(options) {
 				outputPath: options.fs ? plan.outputDir : void 0,
 				mkdir: options.fs ? options.fs.mkdir : void 0,
 				readFileRaw: options.atlas?.readFileRaw ?? options.fs?.readFileRaw,
+				strictOutput: options.fs !== void 0,
 				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();
@@ -3203,7 +3228,9 @@ function publish(options) {
 		}
 		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 outputPlan = plans.find((plan) => !!plan.outputDir);
+			if (outputPlan) throw new Error(`publish: Output for package "${outputPlan.pkg.getName()}" requires a filesystem. Omit output and publish paths to run a layout-only transform.`);
+			logger.info(`publish: Layout computed for ${allPackages.length} package(s); no output directory was requested.`);
 			const noopWriterFs = toBinaryWriterFileSystem(createNoopPublishFs());
 			for (const plan of plans) await publishPackage(plan, noopWriterFs, allDocPackages.indexOf(plan.pkg));
 			await runPublishPluginHook(plugins, "onPublishEnd", doc, options);

package/dist/web.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_publish = require("./publish-CtCXsMdj.cjs");
+const require_publish = require("./publish-D7268_u4.cjs");
 let _openfairygui_core = require("@openfairygui/core");
 //#region src/adapters/web/publish.ts
 function getBrowserContext(canvas) {

package/dist/web.js

@@ -1,4 +1,4 @@
-import { t as publish } from "./publish-Bl-GK9kt.js";
+import { t as publish } from "./publish-DsPK0SJ1.js";
 import { ProjectType } from "@openfairygui/core";
 //#region src/adapters/web/publish.ts
 function getBrowserContext(canvas) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openfairygui/functions",
-  "version": "0.2.0-alpha.13",
+  "version": "0.2.0-alpha.15",
   "description": "FairyGUI Headless Authoring SDK — composable transform functions.",
   "author": "OpenFairyGUI Contributors",
   "license": "MIT",
@@ -74,7 +74,7 @@
   ],
   "dependencies": {
     "jiti": "^2.6.1",
-    "@openfairygui/core": "0.2.0-alpha.13"
+    "@openfairygui/core": "0.2.0-alpha.15"
   },
   "devDependencies": {
     "ava": "^7.0.0",

package/src/adapters/node/publish.ts

@@ -1,8 +1,8 @@
 import type { Document } from '@openfairygui/core';
 import { resolveProjectBasePath } from '../../codegen.js';
-import { publish, type PublishOptions } from '../../publish.js';
-import type { AtlasRasterBackend, PublishFileSystem } from '../../publish/contracts.js';
 import type { LoadedPlugin } from '../../plugins/types.js';
+import type { AtlasRasterBackend, PublishFileSystem } from '../../publish/contracts.js';
+import { type PublishOptions, publish } from '../../publish.js';
 import { loadPlugins } from './plugins.js';
 
 const importNative = new Function('id', 'return import(id)') as <T>(id: string) => Promise<T>;
@@ -68,8 +68,9 @@ async function resolveNodeAssetsPath(document: Document, assetsPath: string | un
 
 async function loadSharpBackend(): Promise<AtlasRasterBackend | undefined> {
 	try {
-		const sharp = await importNative<typeof import('sharp')>('sharp');
-		return (sharp.default ?? sharp) as unknown as AtlasRasterBackend;
+		const loaded = await importNative<typeof import('sharp')>('sharp');
+		const sharp = loaded as unknown as { default?: AtlasRasterBackend };
+		return sharp.default ?? (loaded as unknown as AtlasRasterBackend);
 	} catch {
 		return undefined;
 	}
@@ -110,7 +111,7 @@ export async function publishNode(options: PublishNodeOptions): Promise<void> {
 	]);
 
 	if (!encoder) {
-		document.getLogger().warn('publish: Sharp is unavailable; atlas layout will be generated without PNG output.');
+		throw new Error('publishNode: Sharp is required for a complete publish. Install sharp or provide an encoder.');
 	}
 
 	await document.transform(

package/src/adapters/web/publish.ts

@@ -63,6 +63,7 @@ type BrowserCanvas = OffscreenCanvas | HTMLCanvasElement;
 interface BrowserContext {
 	clearRect(x: number, y: number, width: number, height: number): void;
 	drawImage(image: CanvasImageSource, dx: number, dy: number): void;
+	drawImage(image: CanvasImageSource, dx: number, dy: number, dw: number, dh: number): void;
 	drawImage(
 		image: CanvasImageSource,
 		sx: number,

package/src/atlas.ts

@@ -1,16 +1,16 @@
 import {
-	GearType,
-	TransitionActionType,
 	type Component,
 	type Document,
 	type DragonBonesResource,
 	type FontResource,
+	GearType,
 	type ILogger,
 	type ImageResource,
 	type MovieClipResource,
 	type Package,
 	type SpineResource,
 	type Transform,
+	TransitionActionType,
 } from '@openfairygui/core';
 import { COMPAT_NODE_RECT_FLAGS, type CompatNodeRect } from './max-rects-compat.js';
 import { MaxRectsPackerCompat } from './max-rects-packer-compat.js';
@@ -76,6 +76,14 @@ export interface AtlasOptions {
 	 */
 	outputPath?: string;
 
+	/**
+	 * Require a complete raster artifact when there are packable inputs.
+	 * This is used by publish() so a runtime package cannot contain atlas
+	 * references without the matching PNG output.
+	 * @internal
+	 */
+	strictOutput?: boolean;
+
 	/**
 	 * Optional mkdir function to ensure output directory exists.
 	 * If not provided, the outputPath directory must already exist.
@@ -129,6 +137,7 @@ const ATLAS_DEFAULTS: Required<
 	directSingleImageOutput: false,
 	extractAlpha: false,
 	separatedAtlasForBranch: false,
+	strictOutput: false,
 };
 
 /** Trim info for a single image. */
@@ -420,12 +429,13 @@ export function atlas(_options: AtlasOptions = {}): Transform {
 
 		for (const pkg of root.listPackages()) {
 			if (packageFilter && !packageFilter.has(pkg.getName())) continue;
-			// Respect publish-selected resources when publish() precomputes a merged branch view.
-			const selectedPublishIds = new Set(
-				((pkg.getExtras() as PackageAtlasExtras | undefined) ?? {}).publishedResourceIds ?? [],
-			);
+			// Publish annotations select merged resources; only strict output treats an empty selection as explicit.
+			const publishedResourceIds = (pkg.getExtras() as PackageAtlasExtras | undefined)?.publishedResourceIds;
+			const selectedPublishIds = new Set(publishedResourceIds);
+			const hasPublishSelection =
+				publishedResourceIds !== undefined && (options.strictOutput || selectedPublishIds.size > 0);
 			const allResources =
-				selectedPublishIds.size > 0
+				hasPublishSelection
 					? pkg.listResources().filter((resource) => selectedPublishIds.has(resource.getId()))
 					: pkg.listResources();
 			const skeletonDependencyImageIds = getSelectedSkeletonDependencyImageIds(allResources);
@@ -568,6 +578,11 @@ export function atlas(_options: AtlasOptions = {}): Transform {
 			}
 
 			if (inputs.length === 0) continue;
+			if (options.strictOutput && (!encoder || !options.basePath || !options.outputPath)) {
+				throw new Error(
+					`atlas: Package "${pkg.getName()}" requires encoder, basePath, and outputPath for complete raster output.`,
+				);
+			}
 			let totalPageCount = 0;
 			let usedDirectOutput = false;
 			const { autoInputs, fixedPageGroups, standaloneGroups, reservedPageIndexes } = groupStandaloneInputs(
@@ -733,7 +748,7 @@ async function emitPagedAtlasGroup(
 ): Promise<number> {
 	if (inputs.length === 0) return 0;
 	const pages = packAtlasPages(inputs, context.options, context.forceSinglePage === true);
-	if (pages.length === 0) return 0;
+	assertPackedInputCoverage(pages, inputs.length, `package "${pkg.getName()}"`);
 
 	for (let pageOffset = 0; pageOffset < pages.length; pageOffset += 1) {
 		const page = pages[pageOffset];
@@ -780,9 +795,9 @@ async function emitStandaloneAtlasGroup(
 			? { powerOfTwo: false, multipleOfFour: false, square: false }
 			: group.sizeMode === 'multipleOf4'
 				? { powerOfTwo: false, multipleOfFour: true, square: false }
-				: undefined,
+			: undefined,
 	);
-	if (pages.length === 0) return 0;
+	assertPackedInputCoverage(pages, group.inputs.length, `standalone texture in package "${pkg.getName()}"`);
 
 	for (let pageOffset = 0; pageOffset < pages.length; pageOffset += 1) {
 		const page = pages[pageOffset];
@@ -844,6 +859,21 @@ function packAtlasPages(
 	return packer.pack(inputs.map((input, index) => inputToCompatRect(input, index))) ?? [];
 }
 
+function assertPackedInputCoverage(
+	pages: Array<{ outputRects: Array<{ index: number }> }>,
+	inputCount: number,
+	label: string,
+): void {
+	const packedIndexes = new Set<number>();
+	for (const page of pages) {
+		for (const outputRect of page.outputRects) packedIndexes.add(outputRect.index);
+	}
+	const hasEveryInput = Array.from({ length: inputCount }, (_, index) => packedIndexes.has(index)).every(Boolean);
+	if (packedIndexes.size !== inputCount || !hasEveryInput) {
+		throw new Error(`atlas: Could not pack every input for ${label}.`);
+	}
+}
+
 function attachSpritesToAtlas(
 	doc: Document,
 	allResources: PackageResource[],
@@ -928,7 +958,9 @@ async function writeAtlasPageImage(
 				imageBuffer = input.rasterizedBuffer;
 			} else {
 				if (!isImageResource(input.resource)) {
-					logger.warn(`atlas: Non-image input "${input.id}" is missing inline buffer, skipping compositing.`);
+					const message = `atlas: Non-image input "${input.id}" is missing inline buffer.`;
+					if (options.strictOutput) throw new Error(message);
+					logger.warn(`${message} Skipping compositing.`);
 					continue;
 				}
 				const filePath = _resolveImagePath(input.resource, pkg, options.basePath!);
@@ -941,7 +973,9 @@ async function writeAtlasPageImage(
 				top: packedRect.y,
 			});
 		} catch {
-			logger.warn(`atlas: Could not read image "${input.id}" for compositing.`);
+			const message = `atlas: Could not read image "${input.id}" for compositing.`;
+			if (options.strictOutput) throw new Error(message);
+			logger.warn(message);
 		}
 	}
 
@@ -1080,7 +1114,9 @@ async function emitDirectImageOutput(
 				.toFile(outputFile);
 		}
 	} catch {
-		logger.warn(`atlas: Could not write direct-output atlas "${atlasFileName}".`);
+		const message = `atlas: Could not write direct-output atlas "${atlasFileName}".`;
+		if (options.strictOutput) throw new Error(message);
+		logger.warn(message);
 	}
 }
 
@@ -1472,6 +1508,9 @@ async function _collectImage(
 				sourceHasAlpha = true;
 			}
 		} catch {
+			if (options.strictOutput) {
+				throw new Error(`atlas: Could not read image "${filePath}".`);
+			}
 			if (origW === 0 || origH === 0) {
 				logger.warn(`atlas: Could not read image "${filePath}", skipping.`);
 				return;
@@ -1526,7 +1565,15 @@ async function _collectMovieClipFrames(
 	options: AtlasOptions,
 	logger: ILogger,
 ): Promise<void> {
-	if (!options.basePath || !options.readFileRaw) return;
+	if (!options.basePath || !options.readFileRaw) {
+		if (options.strictOutput) {
+			throw new Error(`atlas: MovieClip "${resource.getId()}" requires basePath and readFileRaw for complete raster output.`);
+		}
+		return;
+	}
+	if (!encoder && options.strictOutput) {
+		throw new Error(`atlas: MovieClip "${resource.getId()}" requires an encoder for complete raster output.`);
+	}
 
 	const mcId = resource.getId();
 	const mcName = resource.getName() + '.jta';
@@ -1562,7 +1609,13 @@ async function _collectMovieClipFrames(
 				const exportFrameIndex = firstFrameIndexByTextureIndex.get(textureIndex);
 				if (exportFrameIndex === undefined) continue;
 				const itemId = `${mcId}_${exportFrameIndex}`;
-				const input = await _createMovieClipFrameInput(jta.frames[textureIndex], itemId, resource, encoder);
+			const input = await _createMovieClipFrameInput(
+				jta.frames[textureIndex],
+				itemId,
+				resource,
+				encoder,
+				options.strictOutput,
+			);
 				if (!input) continue;
 				inputs.push(input);
 				spriteIdByTextureIndex.set(textureIndex, itemId);
@@ -1584,7 +1637,13 @@ async function _collectMovieClipFrames(
 		} else {
 			for (let frameIndex = 0; frameIndex < jta.frames.length; frameIndex += 1) {
 				const itemId = `${mcId}_${frameIndex}`;
-				const input = await _createMovieClipFrameInput(jta.frames[frameIndex], itemId, resource, encoder);
+				const input = await _createMovieClipFrameInput(
+					jta.frames[frameIndex],
+					itemId,
+					resource,
+					encoder,
+					options.strictOutput,
+				);
 				if (!input) continue;
 				inputs.push(input);
 				const frame = doc.createMovieFrame(itemId);
@@ -1604,7 +1663,9 @@ async function _collectMovieClipFrames(
 			resource.setHeight(jta.meta?.height ?? 0);
 		}
 	} catch {
-		logger.warn(`atlas: Could not parse MovieClip "${filePath}", skipping frames.`);
+		const message = `atlas: Could not parse MovieClip "${filePath}".`;
+		if (options.strictOutput) throw new Error(message);
+		logger.warn(`${message} Skipping frames.`);
 	}
 }
 
@@ -1613,6 +1674,7 @@ async function _createMovieClipFrameInput(
 	itemId: string,
 	resource: MovieClipResource,
 	encoder: AtlasRasterBackend | undefined,
+	strictOutput: boolean,
 ): Promise<InputItem | null> {
 	if (!encoder || buffer.length === 0) return null;
 	try {
@@ -1633,6 +1695,7 @@ async function _createMovieClipFrameInput(
 			sourceKind: 'movieclip-frame',
 		};
 	} catch {
+		if (strictOutput) throw new Error(`atlas: Could not decode MovieClip frame "${itemId}".`);
 		return null;
 	}
 }