@nodecraft/rendermite 1.0.5 → 1.0.7

package/dist/run-B0qPw3zf.js

@@ -0,0 +1,209 @@
+import { n as ResourceLocator } from "./locator-ycZzh_6z.js";
+import { n as discoverItems } from "./discovery-0SM0cTLw.js";
+import { r as encodeRasterAsset } from "./encode-Df_tWzkl.js";
+import { t as classifyItemStyle } from "./item-styles-upgEO1yP.js";
+import { t as minifyStylesheet } from "./minify-bjMRmr5J.js";
+import { t as generateStylesheet } from "./stylesheet-CovT3B2S.js";
+import { t as ItemPipeline } from "./pipeline-Da2Kavba.js";
+import { t as describeResources } from "./descriptor-DWebtkI1.js";
+import { t as WorkerRenderPool } from "./pool-CKGp1qup.js";
+import path from "node:path";
+import os from "node:os";
+import { mkdir, writeFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+//#region src/run.ts
+/**
+* Render-run orchestration: discover items, evaluate definitions, render,
+* encode, write images + stylesheet + item list. Unlike upstream, failures are
+* per-item, collected, and reported — a run summary counts files, never log lines.
+*
+* Items render in worker threads when the resource tree can describe itself
+* (see resources/descriptor.ts); otherwise the same pipeline runs in-process.
+*/
+async function run(options) {
+	const namespaces = options.namespaces ?? ["minecraft"];
+	const size = options.size ?? 64;
+	const quality = options.quality ?? 2;
+	const prefix = options.prefix ?? "rc-";
+	const format = options.format ?? "webp";
+	const fallback = options.fallback ?? true;
+	const lightingProfile = options.lightingProfile ?? "modern";
+	const settings = {
+		builtin: options.builtin,
+		output: options.output,
+		size,
+		quality,
+		format,
+		gif: options.gif,
+		avif: options.avif,
+		lightingProfile,
+		animation: options.animation
+	};
+	const concurrency = Math.max(1, options.concurrency ?? 8);
+	const requestedWorkers = resolveWorkerCount(options.workers);
+	const descriptor = requestedWorkers > 1 ? describeResources(options.resources) : null;
+	const pool = descriptor ? new WorkerRenderPool({
+		workerUrl: workerUrl(),
+		workerData: {
+			resources: descriptor,
+			settings,
+			sharpConcurrency: Math.max(1, Math.round(os.availableParallelism() / requestedWorkers))
+		},
+		workers: requestedWorkers,
+		inFlight: concurrency
+	}) : null;
+	const usedWorkers = pool ? requestedWorkers : 1;
+	const pipeline = await ItemPipeline.create(options.resources, settings).catch(async (err) => {
+		await pool?.close();
+		throw err;
+	});
+	const { resources } = pipeline;
+	const glint = await resolveEnchantmentGlint(resources);
+	if (!glint) throw new Error("Missing enchantment glint texture (minecraft:misc/enchanted_glint_item or enchanted_item_glint)");
+	const encodedGlint = await encodeRasterAsset(glint, fallback ? ["png", format] : [format]);
+	const ids = [];
+	const seen = /* @__PURE__ */ new Set();
+	if (options.builtin) for (const placeholder of ["renderchest:unknown", "renderchest:empty"]) {
+		seen.add(placeholder);
+		ids.push(placeholder);
+	}
+	for (const namespace of namespaces) for (const item of await discoverItems(resources, namespace, { filterUntranslatedModels: options.filterUntranslatedModels })) {
+		if (seen.has(item.id)) continue;
+		if (options.builtin && !await itemExistsIn(options.resources, item.id)) continue;
+		seen.add(item.id);
+		ids.push(item.id);
+	}
+	if (pipeline.dynamicItems && namespaces.includes("minecraft")) {
+		const hasTrims = await resources.hasResource("texture", ResourceLocator.parse("minecraft:trims/color_palettes/trim_palette"));
+		const groupAvailable = {
+			_armor_trims: hasTrims,
+			_leather_armor: hasTrims,
+			_decorated_pot: await resources.hasResource("texture", ResourceLocator.parse("minecraft:entity/decorated_pot/decorated_pot_base")),
+			_crossbow: await resources.hasResource("model", ResourceLocator.parse("minecraft:item/crossbow_arrow"))
+		};
+		for (const id of pipeline.dynamicItems) if ((groupAvailable[id.split(":", 1)[0]] ?? true) && !seen.has(id)) {
+			seen.add(id);
+			ids.push(id);
+		}
+	}
+	const rendered = [];
+	const failed = [];
+	const spriteFallbacks = [];
+	const skippedTemplates = [];
+	const styles = [];
+	let writtenFiles = 0;
+	await mkdir(options.output, { recursive: true });
+	for (const [extension, buffer] of encodedGlint) {
+		await writeFile(path.join(options.output, `${prefix}enchantment.${extension}`), buffer);
+		writtenFiles++;
+	}
+	let templateParents = null;
+	const loadTemplateParents = async () => {
+		const parents = /* @__PURE__ */ new Set();
+		for (const namespace of namespaces) for (const modelLocator of await resources.listResources("model", namespace)) {
+			if (!modelLocator.path.startsWith("item/")) continue;
+			const raw = await resources.getResource("model", modelLocator);
+			if (!raw) continue;
+			try {
+				const parent = JSON.parse(raw.toString("utf8")).parent;
+				if (typeof parent === "string") parents.add(ResourceLocator.parse(parent).toString());
+			} catch {}
+		}
+		return parents;
+	};
+	const isTemplateModel = async (id) => {
+		const locator = ResourceLocator.parse(id);
+		if (await resources.hasResource("itemDefinition", locator)) return false;
+		templateParents ??= loadTemplateParents();
+		return (await templateParents).has(new ResourceLocator(locator.namespace, `item/${locator.path}`).toString());
+	};
+	let completed = 0;
+	const record = async (id, outcome, error) => {
+		if (outcome) {
+			writtenFiles += outcome.written;
+			rendered.push(id);
+			if (outcome.usedFallback) spriteFallbacks.push(id);
+		} else if (await isTemplateModel(id).catch(() => false)) skippedTemplates.push(id);
+		else failed.push({
+			id,
+			error: error ?? "Unknown render failure"
+		});
+		completed++;
+		options.onProgress?.(completed, ids.length, id, outcome ? void 0 : error);
+	};
+	if (pool) {
+		const pending = [];
+		await pool.run(ids.map((id) => {
+			return { id };
+		}), (message) => {
+			pending.push(record(message.id, message.result ?? null, message.error));
+		});
+		await Promise.all(pending);
+	} else {
+		let nextIndex = 0;
+		await Promise.all(Array.from({ length: Math.min(concurrency, ids.length) }, async () => {
+			while (nextIndex < ids.length) {
+				const id = ids[nextIndex++];
+				try {
+					await record(id, await pipeline.renderItem(id));
+				} catch (err) {
+					await record(id, null, err.message);
+				}
+			}
+		}));
+	}
+	rendered.sort((left, right) => left.localeCompare(right));
+	const renderedSet = new Set(rendered);
+	for (const id of rendered) {
+		const style = classifyItemStyle(id, renderedSet);
+		if (style) styles.push(style);
+	}
+	const stylesheet = generateStylesheet(styles, {
+		prefix,
+		format,
+		fallback
+	});
+	const finalStylesheet = options.minify === false ? stylesheet : minifyStylesheet(stylesheet, (message) => options.onProgress?.(0, 0, "stylesheet", message));
+	await writeFile(path.join(options.output, `${prefix}${namespaces[0]}-${size}.css`), finalStylesheet);
+	if (options.itemList !== false) {
+		await writeFile(path.join(options.output, `${prefix}${namespaces[0]}.json`), JSON.stringify(rendered));
+		await writeFile(path.join(options.output, `${prefix}${namespaces[0]}-failures.json`), JSON.stringify(failed, null, "	"));
+	}
+	return {
+		rendered,
+		failed,
+		spriteFallbacks,
+		skippedTemplates,
+		writtenFiles,
+		workers: usedWorkers
+	};
+}
+/**
+* One thread per core less the orchestrator, capped at 8: measured throughput
+* on a 16-thread host peaks around 4-8 workers and falls off above that, where
+* per-worker asset caches and libvips threads start competing for the same cores.
+*/
+function resolveWorkerCount(requested) {
+	if (requested !== void 0) return Math.max(1, Math.floor(requested));
+	return Math.min(8, Math.max(1, os.availableParallelism() - 1));
+}
+/** The worker's own file, in whichever form this module was loaded from. */
+function workerUrl() {
+	const extension = path.extname(fileURLToPath(import.meta.url)) || ".js";
+	return new URL(`./workers/render-worker${extension}`, import.meta.url);
+}
+async function itemExistsIn(resources, id) {
+	const locator = ResourceLocator.parse(id);
+	if (await resources.hasResource("itemDefinition", locator)) return true;
+	return resources.hasResource("model", new ResourceLocator(locator.namespace, `item/${locator.path}`));
+}
+/** Resolve both names used on either side of Minecraft 1.19.3. */
+async function resolveEnchantmentGlint(resources) {
+	for (const path of ["misc/enchanted_glint_item", "misc/enchanted_item_glint"]) {
+		const texture = await resources.getResource("texture", new ResourceLocator("minecraft", path));
+		if (texture) return texture;
+	}
+	return null;
+}
+//#endregion
+export { run as t };

package/dist/{run-BlSZw9Qk.d.ts → run-CT3VtFqg.d.ts}

@@ -1,5 +1,6 @@
-import { a as ResourceManager } from "./manager-CoZaeQTu.js";
+import { a as ResourceManager } from "./manager-Cv1NeFyF.js";
 import { a as LightingProfileName } from "./lighting-3FGRC3Af.js";
+import { n as AnimationLimits } from "./renderer-B20ssjRm.js";
 //#region src/run.d.ts
 interface RunOptions {
   resources: ResourceManager;
@@ -22,8 +23,15 @@ interface RunOptions {
   avif?: boolean;
   /** Minify the stylesheet via lightningcss (default true). */
   minify?: boolean;
-  /** In-flight items (encode overlaps on libvips' threadpool; default 8). */
+  /** In-flight items per thread (encode overlaps on libvips' threadpool; default 8). */
   concurrency?: number;
+  /**
+   * Render threads. Defaults to one per core (minus the main thread). 1 renders
+   * in-process; a resource tree that cannot be described falls back to that too.
+   */
+  workers?: number;
+  /** Bounds on animated timelines (frame count). */
+  animation?: AnimationLimits;
   /**
    * Drop classic item models with no matching translation (default true).
    * Disable for a prepared asset tree whose own preprocessing has already
@@ -54,6 +62,8 @@ interface RunResult {
   skippedTemplates: string[];
   /** Image files actually written, the only trustworthy success signal. */
   writtenFiles: number;
+  /** Worker threads used; 1 means everything rendered in-process. */
+  workers: number;
 }
 declare function run(options: RunOptions): Promise<RunResult>;
 //#endregion

package/dist/run.d.ts

@@ -1,3 +1,3 @@
 import { l as evaluateItemModel } from "./definition-BwX6Xxv0.js";
-import { i as run, n as RunOptions, r as RunResult, t as ItemFailure } from "./run-BlSZw9Qk.js";
+import { i as run, n as RunOptions, r as RunResult, t as ItemFailure } from "./run-CT3VtFqg.js";
 export { ItemFailure, RunOptions, RunResult, evaluateItemModel, run };

package/dist/run.js

@@ -1,3 +1,3 @@
 import { o as evaluateItemModel } from "./definition-3MBm8ar_.js";
-import { t as run } from "./run-CfnWIRY4.js";
+import { t as run } from "./run-B0qPw3zf.js";
 export { evaluateItemModel, run };

package/dist/{sources-DH9dk3KF.d.ts → sources-B9X9w3qP.d.ts}

@@ -1,5 +1,5 @@
 import { n as ResourceLocator } from "./locator-jDbdUeTd.js";
-import { r as Texture } from "./loader-TFFNV4Jl.js";
+import { r as Texture } from "./loader-Myy22TDL.js";
 //#region src/atlas/sources.d.ts
 declare class AtlasSourceError extends Error {}
 interface AtlasSource {

package/dist/{synthesize-CRgSEmEp.js → synthesize-3Q0aaOnK.js}

@@ -1,5 +1,5 @@
 import { n as ResourceLocator } from "./locator-ycZzh_6z.js";
-import { n as MapResourceManager } from "./synthetic-DC2bSnGe.js";
+import { n as MapResourceManager } from "./synthetic-ZAUjXT7E.js";
 //#region src/mods/synthesize.ts
 /**
 * Model synthesis for mods that ship textures without item models, ported from

package/dist/{synthetic-CDsj--li.d.ts → synthetic-Qk-BSUXO.d.ts}

@@ -1,5 +1,5 @@
 import { n as ResourceLocator } from "./locator-jDbdUeTd.js";
-import { a as ResourceManager, i as ResourceKindName } from "./manager-CoZaeQTu.js";
+import { a as ResourceManager, i as ResourceKindName, s as ResourceDescriptor } from "./manager-Cv1NeFyF.js";
 //#region src/resources/synthetic.d.ts
 /**
  * In-memory resources, used for era shims (synthesized `models/item/generated.json`,
@@ -7,6 +7,8 @@ import { a as ResourceManager, i as ResourceKindName } from "./manager-CoZaeQTu.
  * mutating asset trees on disk like the old pipeline did.
  */
 declare class MapResourceManager implements ResourceManager {
+  /** Rebuild from a describe() payload (worker side). */
+  static fromEntries(entries: Iterable<[string, Uint8Array]>): MapResourceManager;
   private readonly entries;
   set(kind: ResourceKindName, locator: string | ResourceLocator, content: Buffer | string): this;
   getResource(kind: ResourceKindName, locator: ResourceLocator): Promise<Buffer | null>;
@@ -14,6 +16,7 @@ declare class MapResourceManager implements ResourceManager {
   getAllResources(kind: ResourceKindName, locator: ResourceLocator): Promise<Buffer[]>;
   listResources(kind: ResourceKindName, namespace: string): Promise<ResourceLocator[]>;
   listNamespaces(): Promise<string[]>;
+  describe(): ResourceDescriptor;
 }
 /**
  * Restricts a manager to specific resource kinds — donor versions may only
@@ -29,6 +32,7 @@ declare class KindFilteredResourceManager implements ResourceManager {
   getAllResources(kind: ResourceKindName, locator: ResourceLocator): Promise<Buffer[]>;
   listResources(kind: ResourceKindName, namespace: string): Promise<ResourceLocator[]>;
   listNamespaces(): Promise<string[]>;
+  describe(): ResourceDescriptor | null;
 }
 //#endregion
 export { MapResourceManager as n, KindFilteredResourceManager as t };

package/dist/textures/loader.d.ts

@@ -1,2 +1,2 @@
-import { a as TextureMeta, i as TextureLoader, n as AtlasResolverLike, o as TextureResolutionError, r as Texture, t as AnimatedTexture } from "../loader-TFFNV4Jl.js";
+import { a as TextureMeta, i as TextureLoader, n as AtlasResolverLike, o as TextureResolutionError, r as Texture, t as AnimatedTexture } from "../loader-Myy22TDL.js";
 export { AnimatedTexture, AtlasResolverLike, Texture, TextureLoader, TextureMeta, TextureResolutionError };

package/dist/textures/loader.js

@@ -1,2 +1,2 @@
-import { n as TextureLoader, r as TextureResolutionError, t as AnimatedTexture } from "../loader-CBzn3Koc.js";
+import { n as TextureLoader, r as TextureResolutionError, t as AnimatedTexture } from "../loader-CfXMxcEV.js";
 export { AnimatedTexture, TextureLoader, TextureResolutionError };

package/dist/{tints-CuG6GwQJ.js → tints-B8UJmZMu.js}

@@ -1,8 +1,8 @@
 import { r as modTintPackPath } from "./builtin-caYjESh0.js";
 import { a as defaultProperties, o as evaluateItemModel } from "./definition-3MBm8ar_.js";
 import { n as ResourceLocator } from "./locator-ycZzh_6z.js";
-import { t as FolderResourceManager } from "./manager-dfI7b9N4.js";
-import { n as MapResourceManager } from "./synthetic-DC2bSnGe.js";
+import { t as FolderResourceManager } from "./manager-CkletR5K.js";
+import { n as MapResourceManager } from "./synthetic-ZAUjXT7E.js";
 //#region src/mods/tints.ts
 /**
 * Tints for mod items whose colors live in client code rather than asset JSON.

package/dist/{tints-txt-8xI5.d.ts → tints-BH9l0ND0.d.ts}

@@ -1,5 +1,5 @@
-import { i as TextureLoader } from "./loader-TFFNV4Jl.js";
-import { n as TintColor } from "./face-CpVdnf-w.js";
+import { i as TextureLoader } from "./loader-Myy22TDL.js";
+import { r as TintColor } from "./face-C49L66sQ.js";
 import { o as TintDefinition } from "./definition-BwX6Xxv0.js";
 //#region src/render/tints.d.ts
 declare class InvalidTinterDefinitionError extends Error {}

package/dist/versions/legacy-reshape.d.ts

@@ -1,4 +1,4 @@
-import { a as ResourceManager } from "../manager-CoZaeQTu.js";
+import { a as ResourceManager } from "../manager-Cv1NeFyF.js";
 //#region src/versions/legacy-reshape.d.ts
 /**
  * Build an in-memory texture layer for a pre-1.6 jar. `sheets` selects the

package/dist/versions/legacy-reshape.js

@@ -1,2 +1,2 @@
-import { t as reshapeLegacyAssets } from "../legacy-reshape-CewShfF3.js";
+import { t as reshapeLegacyAssets } from "../legacy-reshape-C05SfAPR.js";
 export { reshapeLegacyAssets };

package/dist/versions/prepare.d.ts

@@ -1,2 +1,2 @@
-import { a as compareVersions, i as PrepareOptions, n as EraName, o as eraForVersion, r as GEOMETRY_DONOR_VERSIONS, s as prepareVersionResources, t as Era } from "../prepare-wfWtaz_X.js";
+import { a as compareVersions, i as PrepareOptions, n as EraName, o as eraForVersion, r as GEOMETRY_DONOR_VERSIONS, s as prepareVersionResources, t as Era } from "../prepare-Cs6QDqie.js";
 export { Era, EraName, GEOMETRY_DONOR_VERSIONS, PrepareOptions, compareVersions, eraForVersion, prepareVersionResources };

package/dist/versions/prepare.js

@@ -1,2 +1,2 @@
-import { a as prepareVersionResources, i as eraForVersion, n as GEOMETRY_DONOR_VERSIONS, r as compareVersions, t as Era } from "../prepare-C8wRjAXP.js";
+import { a as prepareVersionResources, i as eraForVersion, n as GEOMETRY_DONOR_VERSIONS, r as compareVersions, t as Era } from "../prepare-Cc8QZ3j0.js";
 export { Era, GEOMETRY_DONOR_VERSIONS, compareVersions, eraForVersion, prepareVersionResources };

package/dist/workers/pool.d.ts

@@ -2,8 +2,14 @@
 /**
  * Worker-thread pool for parallel item rendering. Design goals born from the
  * PHP tool's failure modes (docs/research/mod-failure-taxonomy.md): errors
- * cross the worker boundary as structured data, a dead worker's queue items are
- * requeued not orphaned, and results stream back so output lands incrementally.
+ * cross the worker boundary as structured data, a dead worker's in-flight items
+ * are reported rather than orphaned, and results stream back so output lands
+ * incrementally.
+ *
+ * Workers spawn as soon as the pool is constructed, so their asset indexing
+ * overlaps the caller's own discovery pass; each holds several tasks at once so
+ * native encoding overlaps the next item's rasterization; and the queue drains
+ * through a cursor, because shift() on a 400k-item array is quadratic.
  */
 interface WorkerTask {
   id: string;
@@ -16,8 +22,33 @@ interface WorkerResult<T> {
 interface PoolOptions {
   workerUrl: URL;
   workerData: unknown;
-  concurrency: number;
+  /** Worker threads to spawn. */
+  workers: number;
+  /** Tasks held by each worker at once (default 2). */
+  inFlight?: number;
+}
+declare class WorkerRenderPool<T> {
+  private readonly options;
+  private readonly inFlightLimit;
+  private readonly workers;
+  private tasks;
+  private cursor;
+  private started;
+  private onResult;
+  private settle;
+  private settled;
+  /** Workers dying before completing anything mean a bad config, not bad luck. */
+  private startupFailures;
+  constructor(options: PoolOptions);
+  private spawn;
+  private pump;
+  private retire;
+  private fail;
+  private finish;
+  private abort;
+  /** Run every task, calling back as results arrive. Terminates the pool after. */
+  run(tasks: WorkerTask[], onResult: (result: WorkerResult<T>) => void): Promise<void>;
+  close(): Promise<void>;
 }
-declare function runPool<T>(tasks: WorkerTask[], options: PoolOptions, onResult: (result: WorkerResult<T>) => void): Promise<void>;
 //#endregion
-export { PoolOptions, WorkerResult, WorkerTask, runPool };
+export { PoolOptions, WorkerRenderPool, WorkerResult, WorkerTask };

package/dist/workers/pool.js

@@ -1,67 +1,2 @@
-import { Worker } from "node:worker_threads";
-//#region src/workers/pool.ts
-/**
-* Worker-thread pool for parallel item rendering. Design goals born from the
-* PHP tool's failure modes (docs/research/mod-failure-taxonomy.md): errors
-* cross the worker boundary as structured data, a dead worker's queue items are
-* requeued not orphaned, and results stream back so output lands incrementally.
-*/
-async function runPool(tasks, options, onResult) {
-	const queue = [...tasks];
-	const inFlight = /* @__PURE__ */ new Map();
-	await new Promise((resolve) => {
-		let active = 0;
-		const spawn = () => {
-			const worker = new Worker(options.workerUrl, { workerData: options.workerData });
-			active++;
-			const next = () => {
-				const task = queue.shift();
-				if (task === void 0) {
-					worker.terminate().catch(() => {});
-					active--;
-					if (active === 0) resolve();
-					return;
-				}
-				inFlight.set(worker, task);
-				worker.postMessage(task);
-			};
-			worker.on("message", (message) => {
-				inFlight.delete(worker);
-				onResult(message);
-				next();
-			});
-			worker.on("error", (err) => {
-				const task = inFlight.get(worker);
-				inFlight.delete(worker);
-				if (task) onResult({
-					id: task.id,
-					error: `Worker crashed: ${err.message}`
-				});
-				active--;
-				if (queue.length > 0) spawn();
-				else if (active === 0) resolve();
-			});
-			worker.on("exit", (code) => {
-				const task = inFlight.get(worker);
-				if (task && code !== 0) {
-					inFlight.delete(worker);
-					onResult({
-						id: task.id,
-						error: `Worker exited with code ${code}`
-					});
-					active--;
-					if (queue.length > 0) spawn();
-					else if (active === 0) resolve();
-				}
-			});
-			next();
-		};
-		if (queue.length === 0) {
-			resolve();
-			return;
-		}
-		for (let i = 0; i < Math.min(options.concurrency, queue.length); i++) spawn();
-	});
-}
-//#endregion
-export { runPool };
+import { t as WorkerRenderPool } from "../pool-CKGp1qup.js";
+export { WorkerRenderPool };

package/dist/workers/render-worker.d.ts

@@ -0,0 +1,15 @@
+import { s as ResourceDescriptor } from "../manager-Cv1NeFyF.js";
+import { n as ItemRenderOutcome, r as PipelineSettings } from "../pipeline-HiA3DC71.js";
+//#region src/workers/render-worker.d.ts
+interface RenderWorkerData {
+  resources: ResourceDescriptor;
+  settings: PipelineSettings;
+  /** libvips threads per worker; the pool already saturates the CPU. */
+  sharpConcurrency: number;
+}
+interface RenderWorkerTask {
+  id: string;
+}
+type RenderWorkerOutcome = ItemRenderOutcome;
+//#endregion
+export { RenderWorkerData, RenderWorkerOutcome, RenderWorkerTask };

package/dist/workers/render-worker.js

@@ -0,0 +1,40 @@
+import { t as ItemPipeline } from "../pipeline-Da2Kavba.js";
+import { n as restoreResources } from "../descriptor-DWebtkI1.js";
+import sharp from "sharp";
+import { parentPort, workerData } from "node:worker_threads";
+//#region src/workers/render-worker.ts
+/**
+* Worker entry: rebuilds the run's resource tree from its descriptor, then
+* renders, encodes and writes items on demand. Items are written here rather
+* than shipped back as buffers — the main thread only needs the outcome, and
+* the file write is the run's success signal either way.
+*
+* Messages in are `{ id }`; messages out are `{ id, result }` or `{ id, error }`.
+* Errors cross as strings because Error instances lose their type across the
+* structured-clone boundary.
+*/
+if (!parentPort) throw new Error("render-worker must be started as a worker thread");
+const port = parentPort;
+const data = workerData;
+sharp.concurrency(data.sharpConcurrency);
+const pipeline = await ItemPipeline.create(restoreResources(data.resources), data.settings);
+async function handle(task) {
+	try {
+		const result = await pipeline.renderItem(task.id);
+		port.postMessage({
+			id: task.id,
+			result
+		});
+	} catch (err) {
+		port.postMessage({
+			id: task.id,
+			error: err.message
+		});
+	}
+}
+port.on("message", (task) => {
+	handle(task).catch(() => {});
+});
+port.postMessage({ ready: true });
+//#endregion
+export {};