@rickyzhangca/fpsr 0.0.1

package/dist/index.js

@@ -0,0 +1,1776 @@
+import { d as bakeEntityInfoSilhouette, f as bakeEntityInfoSilhouetteFromImageData, n as perfMark, r as perfMeasure, t as nowMs } from "./profile-DR4i6HDp.js";
+import { A as BLUEPRINT_ICON_TILE_SIZE, C as deconstructionPlannerIcons, D as deconstructionTreesAndRocksOnly, E as deconstructionTileSelectionMode, F as filledBlueprintIcons, I as planBlueprintIcons, M as blueprintIconSignalScale, N as blueprintIconSignalSizePx, O as formatDeconstructionFilterMode, P as blueprintIconSignalYOffsetPx, S as deconstructionEntityFilters, T as deconstructionTileFilters, _ as upgradePlannerMappers, _t as decodeVersion, b as asDeconstructionPlanner, d as DECONSTRUCTION_PLANNER_COLUMNS, dt as BLUEPRINT_ADAPTERS, f as planDeconstructionPlannerDrawList, ft as legacyItemsObjectToInsertPlans, g as upgradePlannerIcons, h as asUpgradePlanner, i as planDrawListInternal, j as blueprintIconSignalCenter, k as formatDeconstructionTileSelectionMode, l as UPGRADE_PLANNER_COLUMNS, m as UPGRADE_PLANNER_SLOT_COUNT, mt as migrateTo2x, p as resolveIconFrameId, pt as migrateDocumentTo2x, t as drawListForTile, u as planUpgradePlannerDrawList, v as DECONSTRUCTION_ENTITY_FILTER_SLOT_COUNT, w as deconstructionTileFilterMode, x as deconstructionEntityFilterMode, y as DECONSTRUCTION_TILE_FILTER_SLOT_COUNT, z as blueprintPrefersPlatformGraphics } from "./tiled-draw-list-Dc-5Ledi.js";
+import { c as FPSR_TEXT_FONT_FALLBACK, l as FPSR_TEXT_FONT_FAMILY, t as executeDrawList, u as fpsrTextFontCss } from "./execute-CRZV5zw1.js";
+import { n as throwIfAborted$1, t as raceWithAbort } from "./abort-CrgARaZd.js";
+import { Zlib, unzlibSync, zlibSync } from "fflate";
+//#region src/book.ts
+var BlueprintSelectError = class extends Error {
+	reason;
+	constructor(reason, message) {
+		super(message ?? reason);
+		this.name = "BlueprintSelectError";
+		this.reason = reason;
+	}
+};
+function isPlannerEntry(entry) {
+	return entry.upgrade_planner !== void 0 || entry.deconstruction_planner !== void 0;
+}
+function flattenBook(book, pathPrefix, depth, out) {
+	const entries = book.blueprints ?? [];
+	for (const entry of entries) {
+		const entryPath = [...pathPrefix, entry.index];
+		if (entry.blueprint) out.push({
+			path: entryPath,
+			label: entry.blueprint.label,
+			depth
+		});
+		if (entry.blueprint_book) flattenBook(entry.blueprint_book, entryPath, depth + 1, out);
+	}
+}
+/**
+* Depth-first flatten of all renderable blueprints inside a (possibly nested) book.
+* Root bare blueprints get path [].
+*/
+function listBlueprints(doc) {
+	if (doc.blueprint) return [{
+		path: [],
+		label: doc.blueprint.label,
+		depth: 0
+	}];
+	if (doc.blueprint_book) {
+		const out = [];
+		flattenBook(doc.blueprint_book, [], 0, out);
+		return out;
+	}
+	return [];
+}
+function findEntryByIndex(book, index) {
+	return (book.blueprints ?? []).find((e) => e.index === index);
+}
+function selectFromBook(book, path) {
+	if (path.length === 0) {
+		const active = book.active_index ?? 0;
+		const entry = findEntryByIndex(book, active);
+		if (!entry) throw new BlueprintSelectError("not-found", `No book entry at active_index ${active}`);
+		if (isPlannerEntry(entry)) throw new BlueprintSelectError("planner", "Active entry is a planner");
+		if (entry.blueprint) return entry.blueprint;
+		if (entry.blueprint_book) return selectFromBook(entry.blueprint_book, []);
+		throw new BlueprintSelectError("empty-book", "Active entry has no blueprint or book");
+	}
+	const head = path[0];
+	if (head === void 0) throw new BlueprintSelectError("not-found", "Empty path");
+	const rest = path.slice(1);
+	const entry = findEntryByIndex(book, head);
+	if (!entry) throw new BlueprintSelectError("not-found", `No book entry at index ${head}`);
+	if (isPlannerEntry(entry)) throw new BlueprintSelectError("planner", `Entry at index ${head} is a planner`);
+	if (rest.length === 0) {
+		if (entry.blueprint) return entry.blueprint;
+		throw new BlueprintSelectError("not-found", `Entry at index ${head} is not a blueprint`);
+	}
+	if (entry.blueprint_book) return selectFromBook(entry.blueprint_book, rest);
+	throw new BlueprintSelectError("not-found", `Entry at index ${head} has no nested book`);
+}
+/**
+* Select a blueprint from a document. Without path, follows active_index through nested books.
+*/
+function selectBlueprint(doc, path) {
+	if (doc.blueprint) {
+		if (path !== void 0 && path.length > 0) throw new BlueprintSelectError("not-found", "Cannot use path on a bare blueprint document");
+		return doc.blueprint;
+	}
+	if (doc.blueprint_book) return selectFromBook(doc.blueprint_book, path ?? []);
+	throw new BlueprintSelectError("not-found", "Document has no blueprint or blueprint book");
+}
+function selectBookFromBook(book, path) {
+	if (path.length === 0) return book;
+	const head = path[0];
+	if (head === void 0) throw new BlueprintSelectError("not-found", "Empty path");
+	const rest = path.slice(1);
+	const entry = findEntryByIndex(book, head);
+	if (!entry) throw new BlueprintSelectError("not-found", `No book entry at index ${head}`);
+	if (isPlannerEntry(entry)) throw new BlueprintSelectError("planner", `Entry at index ${head} is a planner`);
+	if (!entry.blueprint_book) throw new BlueprintSelectError("not-found", `Entry at index ${head} is not a blueprint book`);
+	return selectBookFromBook(entry.blueprint_book, rest);
+}
+/**
+* Select a blueprint book from a document by path.
+* No path / `[]` returns the root book; non-empty paths walk nested books only.
+*/
+function selectBook(doc, path) {
+	if (!doc.blueprint_book) throw new BlueprintSelectError("not-found", "Document has no blueprint book");
+	return selectBookFromBook(doc.blueprint_book, path ?? []);
+}
+function selectUpgradePlannerFromBook(book, path) {
+	if (path.length === 0) throw new BlueprintSelectError("not-found", "Path required to select an upgrade planner");
+	const head = path[0];
+	if (head === void 0) throw new BlueprintSelectError("not-found", "Empty path");
+	const rest = path.slice(1);
+	const entry = findEntryByIndex(book, head);
+	if (!entry) throw new BlueprintSelectError("not-found", `No book entry at index ${head}`);
+	if (rest.length === 0) {
+		if (entry.upgrade_planner) return entry.upgrade_planner;
+		throw new BlueprintSelectError(entry.deconstruction_planner ? "planner" : "not-found", `Entry at index ${head} is not an upgrade planner`);
+	}
+	if (entry.blueprint_book) return selectUpgradePlannerFromBook(entry.blueprint_book, rest);
+	throw new BlueprintSelectError("not-found", `Entry at index ${head} has no nested book`);
+}
+/**
+* Select an upgrade planner from a document.
+* Bare upgrade-planner documents ignore path (or require `[]`).
+* Book documents require a path ending on an `upgrade_planner` entry.
+*/
+function selectUpgradePlanner(doc, path) {
+	if (doc.upgrade_planner) {
+		if (path !== void 0 && path.length > 0) throw new BlueprintSelectError("not-found", "Cannot use path on a bare upgrade planner document");
+		return doc.upgrade_planner;
+	}
+	if (doc.blueprint_book) {
+		if (path === void 0 || path.length === 0) throw new BlueprintSelectError("not-found", "Path required to select an upgrade planner");
+		return selectUpgradePlannerFromBook(doc.blueprint_book, path);
+	}
+	throw new BlueprintSelectError("not-found", "Document has no upgrade planner");
+}
+function selectDeconstructionPlannerFromBook(book, path) {
+	if (path.length === 0) throw new BlueprintSelectError("not-found", "Path required to select a deconstruction planner");
+	const head = path[0];
+	if (head === void 0) throw new BlueprintSelectError("not-found", "Empty path");
+	const rest = path.slice(1);
+	const entry = findEntryByIndex(book, head);
+	if (!entry) throw new BlueprintSelectError("not-found", `No book entry at index ${head}`);
+	if (rest.length === 0) {
+		if (entry.deconstruction_planner) return entry.deconstruction_planner;
+		throw new BlueprintSelectError(entry.upgrade_planner ? "planner" : "not-found", `Entry at index ${head} is not a deconstruction planner`);
+	}
+	if (entry.blueprint_book) return selectDeconstructionPlannerFromBook(entry.blueprint_book, rest);
+	throw new BlueprintSelectError("not-found", `Entry at index ${head} has no nested book`);
+}
+/**
+* Select a deconstruction planner from a document.
+* Bare deconstruction-planner documents ignore path (or require `[]`).
+* Book documents require a path ending on a `deconstruction_planner` entry.
+*/
+function selectDeconstructionPlanner(doc, path) {
+	if (doc.deconstruction_planner) {
+		if (path !== void 0 && path.length > 0) throw new BlueprintSelectError("not-found", "Cannot use path on a bare deconstruction planner document");
+		return doc.deconstruction_planner;
+	}
+	if (doc.blueprint_book) {
+		if (path === void 0 || path.length === 0) throw new BlueprintSelectError("not-found", "Path required to select a deconstruction planner");
+		return selectDeconstructionPlannerFromBook(doc.blueprint_book, path);
+	}
+	throw new BlueprintSelectError("not-found", "Document has no deconstruction planner");
+}
+const ROOT_ID = "root";
+function pathToId(path) {
+	return path.length === 0 ? ROOT_ID : path.join(".");
+}
+function entryKind(entry) {
+	if (entry.blueprint_book) return "book";
+	if (entry.blueprint) return "blueprint";
+	if (entry.upgrade_planner) return "upgrade_planner";
+	if (entry.deconstruction_planner) return "deconstruction_planner";
+	return null;
+}
+function plannerField(planner, key) {
+	return planner?.[key];
+}
+function entryLabel(entry, kind) {
+	if (kind === "book") return entry.blueprint_book?.label ?? "(untitled)";
+	if (kind === "blueprint") return entry.blueprint?.label ?? "(untitled)";
+	if (kind === "upgrade_planner") {
+		const label = plannerField(entry.upgrade_planner, "label");
+		return typeof label === "string" && label.length > 0 ? label : "Upgrade planner";
+	}
+	const label = plannerField(entry.deconstruction_planner, "label");
+	return typeof label === "string" && label.length > 0 ? label : "Deconstruction planner";
+}
+function entryIcons(entry, kind) {
+	if (kind === "book" && entry.blueprint_book) {
+		const icons = blueprintBookCover(entry.blueprint_book).icons;
+		return icons.length > 0 ? icons : void 0;
+	}
+	if (kind === "blueprint") return entry.blueprint?.icons;
+	if (kind === "upgrade_planner" && entry.upgrade_planner) {
+		const icons = upgradePlannerIcons(entry.upgrade_planner);
+		return icons.length > 0 ? icons : void 0;
+	}
+	if (kind === "deconstruction_planner" && entry.deconstruction_planner) {
+		const icons = deconstructionPlannerIcons(entry.deconstruction_planner);
+		return icons.length > 0 ? icons : void 0;
+	}
+}
+const BOOK_COVER_BACKGROUND = "item/blueprint-book";
+/**
+* Inventory thumbnail for a blueprint book: always the composite of the first
+* child entry (lowest `index`), including nested books and planners.
+* Ignores any explicit `book.icons` so the cover tracks book contents.
+*
+* The outer paper is always the book. Planner leaves nest their composite as
+* the cover icon; blueprint leaves place signal icons directly on the book.
+*/
+function blueprintBookCover(book) {
+	const first = [...book.blueprints ?? []].sort((a, b) => a.index - b.index)[0];
+	if (!first) return {
+		icons: [],
+		backgroundKey: BOOK_COVER_BACKGROUND
+	};
+	if (first.blueprint) return {
+		icons: filledBlueprintIcons(first.blueprint.icons),
+		backgroundKey: BOOK_COVER_BACKGROUND
+	};
+	if (first.upgrade_planner) return {
+		icons: [],
+		backgroundKey: BOOK_COVER_BACKGROUND,
+		nested: {
+			backgroundKey: "item/upgrade-planner",
+			icons: upgradePlannerIcons(first.upgrade_planner)
+		}
+	};
+	if (first.deconstruction_planner) return {
+		icons: [],
+		backgroundKey: BOOK_COVER_BACKGROUND,
+		nested: {
+			backgroundKey: "item/deconstruction-planner",
+			icons: deconstructionPlannerIcons(first.deconstruction_planner)
+		}
+	};
+	if (first.blueprint_book) return blueprintBookCover(first.blueprint_book);
+	return {
+		icons: [],
+		backgroundKey: BOOK_COVER_BACKGROUND
+	};
+}
+/** Signal icons for a book cover (nested planner icons when applicable). */
+function blueprintBookCoverIcons(book) {
+	const cover = blueprintBookCover(book);
+	return cover.nested?.icons ?? cover.icons;
+}
+function bookCoverFields(book) {
+	const cover = blueprintBookCover(book);
+	if (cover.nested) return {
+		...cover.nested.icons.length > 0 ? { icons: cover.nested.icons } : {},
+		iconBackgroundKey: cover.nested.backgroundKey
+	};
+	return { ...cover.icons.length > 0 ? { icons: cover.icons } : {} };
+}
+function addBookEntries(book, pathPrefix, items) {
+	const childIds = [];
+	for (const entry of book.blueprints ?? []) {
+		const kind = entryKind(entry);
+		if (!kind) continue;
+		const entryPath = [...pathPrefix, entry.index];
+		const id = pathToId(entryPath);
+		childIds.push(id);
+		const icons = entryIcons(entry, kind);
+		if (kind === "book" && entry.blueprint_book) {
+			const nestedChildren = addBookEntries(entry.blueprint_book, entryPath, items);
+			items[id] = {
+				id,
+				path: entryPath,
+				label: entryLabel(entry, kind),
+				kind,
+				...bookCoverFields(entry.blueprint_book),
+				children: nestedChildren
+			};
+		} else items[id] = {
+			id,
+			path: entryPath,
+			label: entryLabel(entry, kind),
+			kind,
+			icons,
+			children: []
+		};
+	}
+	return childIds;
+}
+/**
+* Build a flat id→item map of the book hierarchy for tree UIs.
+* Returns null when the document is not a blueprint book.
+*/
+function buildBookTree(doc) {
+	if (!doc.blueprint_book) return null;
+	const items = {};
+	const children = addBookEntries(doc.blueprint_book, [], items);
+	items[ROOT_ID] = {
+		id: ROOT_ID,
+		path: [],
+		label: doc.blueprint_book.label ?? "(untitled)",
+		kind: "book",
+		...bookCoverFields(doc.blueprint_book),
+		children
+	};
+	return {
+		rootId: ROOT_ID,
+		items
+	};
+}
+function resolveActivePathFromBook(book, pathPrefix) {
+	const active = book.active_index ?? 0;
+	const entry = findEntryByIndex(book, active);
+	if (!entry) throw new BlueprintSelectError("not-found", `No book entry at active_index ${active}`);
+	const entryPath = [...pathPrefix, entry.index];
+	if (entry.upgrade_planner) return entryPath;
+	if (entry.deconstruction_planner) return entryPath;
+	if (entry.blueprint) return entryPath;
+	if (entry.blueprint_book) return resolveActivePathFromBook(entry.blueprint_book, entryPath);
+	throw new BlueprintSelectError("empty-book", "Active entry has no blueprint or book");
+}
+/**
+* Resolve the concrete blueprint path by following active_index through nested books.
+* Bare blueprint documents return []. Returns null when no active blueprint can be resolved.
+*/
+function resolveActivePath(doc) {
+	if (doc.blueprint) return [];
+	if (!doc.blueprint_book) return null;
+	try {
+		return resolveActivePathFromBook(doc.blueprint_book, []);
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/base64.ts
+/**
+* Cross-environment base64 helpers (browser + Node) without relying on Buffer alone.
+*/
+const hasAtob = typeof globalThis.atob === "function";
+const hasBtoa = typeof globalThis.btoa === "function";
+function bytesToBinary(bytes) {
+	let binary = "";
+	for (let i = 0; i < bytes.length; i++) {
+		const byte = bytes[i];
+		if (byte === void 0) continue;
+		binary += String.fromCharCode(byte);
+	}
+	return binary;
+}
+function binaryToBytes(binary) {
+	const bytes = new Uint8Array(binary.length);
+	for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+	return bytes;
+}
+function base64Encode(bytes) {
+	if (hasBtoa) return globalThis.btoa(bytesToBinary(bytes));
+	const { Buffer } = globalThis;
+	if (Buffer) return Buffer.from(bytes).toString("base64");
+	throw new Error("No base64 encoder available");
+}
+function base64Decode(b64) {
+	if (hasAtob) return binaryToBytes(globalThis.atob(b64));
+	const { Buffer } = globalThis;
+	if (Buffer) return new Uint8Array(Buffer.from(b64, "base64"));
+	throw new Error("No base64 decoder available");
+}
+function utf8Encode(text) {
+	if (typeof TextEncoder !== "undefined") return new TextEncoder().encode(text);
+	const { Buffer } = globalThis;
+	if (Buffer) return new Uint8Array(Buffer.from(text, "utf8"));
+	throw new Error("No UTF-8 encoder available");
+}
+function utf8Decode(bytes) {
+	if (typeof TextDecoder !== "undefined") return new TextDecoder().decode(bytes);
+	const { Buffer } = globalThis;
+	if (Buffer) return Buffer.from(bytes).toString("utf8");
+	throw new Error("No UTF-8 decoder available");
+}
+//#endregion
+//#region src/decode.ts
+var BlueprintDecodeError = class extends Error {
+	reason;
+	constructor(reason, message) {
+		super(message ?? reason);
+		this.name = "BlueprintDecodeError";
+		this.reason = reason;
+	}
+};
+const TOP_LEVEL_KEYS = [
+	"blueprint",
+	"blueprint_book",
+	"upgrade_planner",
+	"deconstruction_planner"
+];
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+const ENTRY_WRAPPER_KEYS = [
+	"blueprint",
+	"blueprint_book",
+	"upgrade_planner",
+	"deconstruction_planner"
+];
+function validateBlueprint(bp, path) {
+	if (bp.item !== "blueprint") throw new BlueprintDecodeError("invalid-document", `${path}.item must be "blueprint"`);
+	if (typeof bp.version !== "number" || !Number.isFinite(bp.version)) throw new BlueprintDecodeError("invalid-document", `${path}.version must be a finite number`);
+}
+function validateBookEntry(entry, path) {
+	if (!isPlainObject(entry)) throw new BlueprintDecodeError("invalid-document", `${path} must be an object`);
+	if (!("index" in entry) || typeof entry.index !== "number" || !Number.isFinite(entry.index)) throw new BlueprintDecodeError("invalid-document", `${path}.index must be a finite number`);
+	const keys = ENTRY_WRAPPER_KEYS.filter((k) => k in entry);
+	if (keys.length !== 1) throw new BlueprintDecodeError("invalid-document", `${path} expected exactly one content key, found ${keys.length}`);
+	const key = keys[0];
+	const value = entry[key];
+	if (value === null || value === void 0) throw new BlueprintDecodeError("invalid-document", `${path}.${key} must be an object, got ${value === null ? "null" : "undefined"}`);
+	if (!isPlainObject(value)) throw new BlueprintDecodeError("invalid-document", `${path}.${key} must be an object`);
+	if (key === "blueprint") validateBlueprint(value, `${path}.blueprint`);
+	else if (key === "blueprint_book") validateBlueprintBook(value, `${path}.blueprint_book`);
+	else `${path}${key}`;
+}
+function validateBlueprintBook(book, path) {
+	if (book.item !== "blueprint-book") throw new BlueprintDecodeError("invalid-document", `${path}.item must be "blueprint-book"`);
+	if (typeof book.version !== "number" || !Number.isFinite(book.version)) throw new BlueprintDecodeError("invalid-document", `${path}.version must be a finite number`);
+	const entries = book.blueprints;
+	if (entries === void 0) return;
+	if (!Array.isArray(entries)) throw new BlueprintDecodeError("invalid-document", `${path}.blueprints must be an array`);
+	for (let i = 0; i < entries.length; i++) validateBookEntry(entries[i], `${path}.blueprints[${i}]`);
+}
+function validateWrapperValue(doc, key) {
+	const value = doc[key];
+	if (value === null || value === void 0) throw new BlueprintDecodeError("invalid-document", `Top-level "${key}" must be an object, got ${value === null ? "null" : "undefined"}`);
+	if (!isPlainObject(value)) throw new BlueprintDecodeError("invalid-document", `Top-level "${key}" must be an object`);
+	if (key === "blueprint") validateBlueprint(value, "blueprint");
+	else if (key === "blueprint_book") validateBlueprintBook(value, "blueprint_book");
+}
+function validateDocument(doc) {
+	if (!isPlainObject(doc)) throw new BlueprintDecodeError("invalid-document", "Document must be an object");
+	const keys = TOP_LEVEL_KEYS.filter((k) => k in doc);
+	if (keys.length !== 1) throw new BlueprintDecodeError("invalid-document", `Expected exactly one top-level key, found ${keys.length}`);
+	const key = keys[0];
+	validateWrapperValue(doc, key);
+	return doc;
+}
+function decodeCompressedWithStats(source) {
+	const tTotal = nowMs();
+	const versionByte = source[0];
+	if (versionByte !== "0") throw new BlueprintDecodeError("unsupported-version", `Unsupported blueprint string version byte: ${versionByte}`);
+	let t = nowMs();
+	let bytes;
+	try {
+		bytes = base64Decode(source.slice(1));
+	} catch {
+		throw new BlueprintDecodeError("invalid-base64", "Invalid base64 payload");
+	}
+	const base64Ms = nowMs() - t;
+	t = nowMs();
+	let inflated;
+	try {
+		inflated = unzlibSync(bytes);
+	} catch {
+		throw new BlueprintDecodeError("inflate-failed", "zlib inflate failed");
+	}
+	const inflateMs = nowMs() - t;
+	t = nowMs();
+	let text;
+	try {
+		text = utf8Decode(inflated);
+	} catch {
+		throw new BlueprintDecodeError("invalid-json", "Invalid UTF-8 after inflate");
+	}
+	const utf8Ms = nowMs() - t;
+	t = nowMs();
+	let parsed;
+	try {
+		parsed = JSON.parse(text);
+	} catch {
+		throw new BlueprintDecodeError("invalid-json", "Invalid JSON after inflate");
+	}
+	const jsonParseMs = nowMs() - t;
+	t = nowMs();
+	const doc = validateDocument(parsed);
+	const validateMs = nowMs() - t;
+	const compressedBytes = bytes.length;
+	const inflatedBytes = inflated.length;
+	return {
+		doc,
+		stats: {
+			mode: "compressed",
+			inputChars: source.length,
+			compressedBytes,
+			inflatedBytes,
+			jsonChars: text.length,
+			compressionRatio: compressedBytes > 0 ? inflatedBytes / compressedBytes : void 0,
+			timings: {
+				totalMs: nowMs() - tTotal,
+				base64Ms,
+				inflateMs,
+				utf8Ms,
+				jsonParseMs,
+				validateMs
+			}
+		}
+	};
+}
+function decodeJsonWithStats(source) {
+	const tTotal = nowMs();
+	let t = nowMs();
+	let parsed;
+	try {
+		parsed = JSON.parse(source);
+	} catch {
+		throw new BlueprintDecodeError("invalid-json", "Invalid raw JSON");
+	}
+	const jsonParseMs = nowMs() - t;
+	t = nowMs();
+	const doc = validateDocument(parsed);
+	const validateMs = nowMs() - t;
+	return {
+		doc,
+		stats: {
+			mode: "json",
+			inputChars: source.length,
+			jsonChars: source.length,
+			timings: {
+				totalMs: nowMs() - tTotal,
+				jsonParseMs,
+				validateMs
+			}
+		}
+	};
+}
+/**
+* Decode a Factorio blueprint string (compressed or raw JSON) into a BlueprintDocument.
+*/
+function decode(source) {
+	return decodeWithStats(source).doc;
+}
+/**
+* Decode a blueprint string and collect size + timing stats for profiling.
+*/
+function decodeWithStats(source) {
+	const trimmed = source.trim();
+	if (trimmed.length === 0) throw new BlueprintDecodeError("invalid-document", "Empty input");
+	if (trimmed.startsWith("{")) return decodeJsonWithStats(trimmed);
+	return decodeCompressedWithStats(trimmed);
+}
+//#endregion
+//#region src/encode.ts
+/**
+* Encode a BlueprintDocument into a Factorio blueprint string (version byte 0).
+*/
+function encode(doc) {
+	return `0${base64Encode(zlibSync(utf8Encode(JSON.stringify(doc)), { level: 9 }))}`;
+}
+//#endregion
+//#region src/blueprint-components.ts
+/** Ground rail pieces that place from the `rail` item. */
+const RAIL_COMPONENT_NAMES = /* @__PURE__ */ new Set([
+	"straight-rail",
+	"curved-rail-a",
+	"curved-rail-b",
+	"half-diagonal-rail",
+	"legacy-straight-rail",
+	"legacy-curved-rail"
+]);
+/**
+* Summarize blueprint inventory for UI (item icons).
+* - Migrates 1.x names first (`migrateTo2x`) so icons resolve in the 2.x render-db
+* - Ground rail pieces (straight/curved/half-diagonal + legacy) → `"rail"`
+* - Tiles → `db.tiles[name].item` when present, else tile prototype name
+* - All other entities → prototype name
+*
+* Sorted by count descending, then name ascending.
+*/
+function countBlueprintComponents(bp, db) {
+	const migrated = migrateTo2x(bp);
+	const counts = /* @__PURE__ */ new Map();
+	for (const entity of migrated.entities ?? []) {
+		const key = RAIL_COMPONENT_NAMES.has(entity.name) ? "rail" : entity.name;
+		counts.set(key, (counts.get(key) ?? 0) + 1);
+	}
+	for (const tile of migrated.tiles ?? []) {
+		const key = db.tiles[tile.name]?.item ?? tile.name;
+		counts.set(key, (counts.get(key) ?? 0) + 1);
+	}
+	return [...counts.entries()].map(([name, count]) => ({
+		name,
+		count
+	})).sort((a, b) => b.count - a.count || a.name.localeCompare(b.name));
+}
+//#endregion
+//#region src/rich-text.ts
+const ICON_TAG_TYPES = /* @__PURE__ */ new Set([
+	"item",
+	"entity",
+	"recipe",
+	"fluid",
+	"virtual-signal",
+	"quality",
+	"space-location",
+	"asteroid-chunk",
+	"img"
+]);
+const RICH_TEXT_PREFIX = {
+	item: "item",
+	entity: "entity",
+	recipe: "recipe",
+	fluid: "fluid",
+	"virtual-signal": "virtual-signal",
+	quality: "quality",
+	"space-location": "space-location",
+	"asteroid-chunk": "asteroid-chunk"
+};
+function parsePayload(payload) {
+	const parts = payload.split(",");
+	const namePart = parts[0]?.trim();
+	if (!namePart) return void 0;
+	let quality;
+	for (let i = 1; i < parts.length; i++) {
+		const segment = parts[i]?.trim();
+		if (!segment) continue;
+		const eq = segment.indexOf("=");
+		if (eq === -1) continue;
+		const key = segment.slice(0, eq).trim();
+		const value = segment.slice(eq + 1).trim();
+		if (key === "quality" && value) quality = value;
+	}
+	return quality ? {
+		name: namePart,
+		quality
+	} : { name: namePart };
+}
+function parseImgPayload(payload) {
+	const slash = payload.indexOf("/");
+	const dot = payload.indexOf(".");
+	const sep = slash !== -1 ? slash : dot !== -1 ? dot : -1;
+	if (sep === -1) return void 0;
+	const type = payload.slice(0, sep).trim();
+	const name = payload.slice(sep + 1).trim();
+	if (!type || !name) return void 0;
+	return {
+		type,
+		name
+	};
+}
+function parseTagContent(content) {
+	const eq = content.indexOf("=");
+	if (eq === -1) return void 0;
+	const tag = content.slice(0, eq).trim();
+	const payload = content.slice(eq + 1).trim();
+	if (!tag || !payload) return void 0;
+	if (!ICON_TAG_TYPES.has(tag)) return void 0;
+	const raw = `[${content}]`;
+	if (tag === "img") {
+		const img = parseImgPayload(payload);
+		if (!img) return void 0;
+		return {
+			kind: "icon",
+			type: img.type,
+			name: img.name,
+			raw
+		};
+	}
+	const parsed = parsePayload(payload);
+	if (!parsed) return void 0;
+	if (tag === "quality") return {
+		kind: "icon",
+		type: "quality",
+		name: parsed.name,
+		raw
+	};
+	const token = {
+		kind: "icon",
+		type: tag,
+		name: parsed.name,
+		raw
+	};
+	if (parsed.quality && parsed.quality !== "normal") return {
+		...token,
+		quality: parsed.quality
+	};
+	return token;
+}
+/**
+* Parse Factorio rich-text icon tags into text and icon tokens.
+* Unrecognized bracket sequences are kept as literal text.
+*/
+function parseRichText(text) {
+	if (!text) return [];
+	const tokens = [];
+	let cursor = 0;
+	while (cursor < text.length) {
+		const open = text.indexOf("[", cursor);
+		if (open === -1) {
+			tokens.push({
+				kind: "text",
+				value: text.slice(cursor)
+			});
+			break;
+		}
+		if (open > cursor) tokens.push({
+			kind: "text",
+			value: text.slice(cursor, open)
+		});
+		const close = text.indexOf("]", open + 1);
+		if (close === -1) {
+			tokens.push({
+				kind: "text",
+				value: text.slice(open)
+			});
+			break;
+		}
+		const parsed = parseTagContent(text.slice(open + 1, close));
+		if (parsed) {
+			tokens.push(parsed);
+			cursor = close + 1;
+		} else {
+			tokens.push({
+				kind: "text",
+				value: text.slice(open, close + 1)
+			});
+			cursor = close + 1;
+		}
+	}
+	return mergeAdjacentText(tokens);
+}
+function mergeAdjacentText(tokens) {
+	const merged = [];
+	for (const token of tokens) {
+		const last = merged.at(-1);
+		if (token.kind === "text" && last?.kind === "text") last.value += token.value;
+		else merged.push(token);
+	}
+	return merged;
+}
+/** Ordered render-db icon keys for a parsed rich-text icon token. */
+function richTextIconKeys(token) {
+	const primary = `${RICH_TEXT_PREFIX[token.type] ?? token.type}/${token.name}`;
+	switch (token.type) {
+		case "item": return [
+			primary,
+			`entity/${token.name}`,
+			`recipe/${token.name}`
+		];
+		case "entity": return [primary, `item/${token.name}`];
+		case "recipe": return [primary, `item/${token.name}`];
+		default: return [primary];
+	}
+}
+/** Whether a quality badge should be drawn on top of this icon token. */
+function richTextIconQuality(token) {
+	if (token.type === "quality") return void 0;
+	if (!token.quality || token.quality === "normal") return void 0;
+	return token.quality;
+}
+/** Strip rich-text tags, keeping only literal text segments. */
+function stripRichText(text) {
+	if (!text) return "";
+	return parseRichText(text).filter((token) => token.kind === "text").map((token) => token.value).join("").trim();
+}
+//#endregion
+//#region src/assets.ts
+async function loadJson(url, fetchImpl, signal) {
+	const t0 = nowMs();
+	const res = await fetchImpl(url, signal ? { signal } : void 0);
+	if (!res.ok) throw new Error(`Failed to fetch ${url}: ${res.status} ${res.statusText}`);
+	const body = await res.arrayBuffer();
+	const fetchMs = nowMs() - t0;
+	const text = new TextDecoder().decode(body);
+	return {
+		value: JSON.parse(text),
+		bytes: body.byteLength,
+		fetchMs
+	};
+}
+function decodeLimiter(limit) {
+	let active = 0;
+	const waiting = [];
+	const acquire = () => {
+		if (active < limit) {
+			active++;
+			return Promise.resolve();
+		}
+		return new Promise((resolve) => {
+			waiting.push(() => {
+				active++;
+				resolve();
+			});
+		});
+	};
+	const release = () => {
+		active--;
+		waiting.shift()?.();
+	};
+	return async (task) => {
+		const queuedAt = nowMs();
+		await acquire();
+		const queueMs = nowMs() - queuedAt;
+		try {
+			return {
+				value: await task(),
+				queueMs
+			};
+		} finally {
+			release();
+		}
+	};
+}
+async function blobToImage(blob, decodeImage, signal) {
+	throwIfAborted$1(signal);
+	const t0 = nowMs();
+	if (typeof createImageBitmap === "function") {
+		const image = await createImageBitmap(blob);
+		throwIfAborted$1(signal);
+		return {
+			image,
+			decodeMs: nowMs() - t0
+		};
+	}
+	if (decodeImage) {
+		const image = await decodeImage(blob, signal);
+		throwIfAborted$1(signal);
+		return {
+			image,
+			decodeMs: nowMs() - t0
+		};
+	}
+	throw new Error("createImageBitmap is unavailable; pass cdnAssets(baseUrl, { decodeImage }) or use localAssets from fpsr/node");
+}
+/**
+* Fetch-based AssetSource for CDN (or any HTTP) layouts:
+*   {baseUrl}/manifest.json
+*   {baseUrl}/{manifest.tiers[tier].renderDb.file}
+*   {baseUrl}/{atlas.file}
+*/
+function cdnAssets(baseUrl, options) {
+	const root = baseUrl.replace(/\/+$/, "");
+	const fetchImpl = options?.fetchImpl ?? fetch;
+	const onAssetEvent = options?.onAssetEvent;
+	const withDecodeSlot = decodeLimiter(Math.max(1, Math.floor(options?.maxConcurrentDecodes ?? 2)));
+	let manifestPromise;
+	let manifestReady = false;
+	const dbPromises = /* @__PURE__ */ new Map();
+	const dbReady = /* @__PURE__ */ new Set();
+	const atlasCache = /* @__PURE__ */ new Map();
+	const atlasReady = /* @__PURE__ */ new Set();
+	let fontsPromise;
+	/**
+	* Shared loads intentionally omit AbortSignal so one cancelled waiter does
+	* not cancel the underlying fetch for other consumers. Waiters race via
+	* {@link raceWithAbort}.
+	*/
+	const loadManifest = () => {
+		if (!manifestPromise) {
+			const url = `${root}/manifest.json`;
+			manifestPromise = (async () => {
+				const t0 = nowMs();
+				const { value, bytes, fetchMs } = await loadJson(url, fetchImpl);
+				if (value.schema !== 2) throw new Error(`Unsupported asset manifest schema: ${String(value.schema)}`);
+				if (!value.tiers?.["1x"]?.renderDb.file || !value.tiers?.["2x"]?.renderDb.file) throw new Error("Asset manifest is missing required 1x/2x tiers");
+				onAssetEvent?.({
+					kind: "manifest",
+					url,
+					cached: false,
+					fetchMs,
+					totalMs: nowMs() - t0,
+					bytes
+				});
+				manifestReady = true;
+				return value;
+			})().catch((error) => {
+				manifestPromise = void 0;
+				manifestReady = false;
+				throw error;
+			});
+		} else if (manifestReady) onAssetEvent?.({
+			kind: "manifest",
+			url: `${root}/manifest.json`,
+			cached: true,
+			totalMs: 0
+		});
+		return manifestPromise;
+	};
+	return {
+		loadRenderDb(tier = "2x", loadOptions) {
+			throwIfAborted$1(loadOptions?.signal);
+			let pending = dbPromises.get(tier);
+			if (!pending) {
+				pending = (async () => {
+					const t0 = nowMs();
+					const manifest = await loadManifest();
+					const url = `${root}/${manifest.tiers[tier].renderDb.file}`;
+					const { value, bytes, fetchMs } = await loadJson(url, fetchImpl);
+					if (value.schema !== 2) throw new Error(`Unsupported render-db schema: ${String(value.schema)}`);
+					onAssetEvent?.({
+						kind: "render-db",
+						tier,
+						url,
+						cached: false,
+						fetchMs,
+						totalMs: nowMs() - t0,
+						bytes
+					});
+					dbReady.add(tier);
+					return value;
+				})().catch((error) => {
+					dbPromises.delete(tier);
+					dbReady.delete(tier);
+					throw error;
+				});
+				dbPromises.set(tier, pending);
+			} else if (dbReady.has(tier)) onAssetEvent?.({
+				kind: "render-db",
+				tier,
+				url: void 0,
+				cached: true,
+				totalMs: 0
+			});
+			return raceWithAbort(pending, loadOptions?.signal);
+		},
+		loadAtlasImage(index, tier = "2x", loadOptions) {
+			throwIfAborted$1(loadOptions?.signal);
+			const cacheKey = `${tier}:${index}`;
+			let pending = atlasCache.get(cacheKey);
+			if (!pending) {
+				pending = (async () => {
+					const t0 = nowMs();
+					const entry = (await loadManifest()).tiers[tier].atlases[index];
+					if (!entry) throw new Error(`Atlas index ${index} missing from manifest`);
+					const url = `${root}/${entry.file}`;
+					const tFetch = nowMs();
+					const res = await fetchImpl(url);
+					if (!res.ok) throw new Error(`Failed to fetch atlas ${url}: ${res.status}`);
+					const blob = await res.blob();
+					const fetchMs = nowMs() - tFetch;
+					const { value: decoded, queueMs } = await withDecodeSlot(() => blobToImage(blob, options?.decodeImage));
+					const { image, decodeMs } = decoded;
+					onAssetEvent?.({
+						kind: "atlas",
+						index,
+						tier,
+						url,
+						cached: false,
+						fetchMs,
+						queueMs,
+						decodeMs,
+						decodedPixels: entry.w * entry.h,
+						totalMs: nowMs() - t0,
+						bytes: blob.size
+					});
+					atlasReady.add(cacheKey);
+					return image;
+				})().catch((error) => {
+					atlasCache.delete(cacheKey);
+					atlasReady.delete(cacheKey);
+					throw error;
+				});
+				atlasCache.set(cacheKey, pending);
+			} else if (atlasReady.has(cacheKey)) onAssetEvent?.({
+				kind: "atlas",
+				index,
+				tier,
+				cached: true,
+				totalMs: 0
+			});
+			return raceWithAbort(pending, loadOptions?.signal);
+		},
+		ensureFonts(loadOptions) {
+			throwIfAborted$1(loadOptions?.signal);
+			if (!fontsPromise) fontsPromise = (async () => {
+				try {
+					const fonts = (await loadManifest()).fonts ?? [];
+					if (fonts.length === 0) return;
+					if (typeof FontFace === "undefined" || typeof document === "undefined") return;
+					await Promise.all(fonts.map(async (font) => {
+						const url = `${root}/${font.file}`;
+						const loaded = await new FontFace(font.family, `url(${url})`).load();
+						document.fonts.add(loaded);
+					}));
+				} catch {}
+			})();
+			return raceWithAbort(fontsPromise, loadOptions?.signal);
+		},
+		dispose() {
+			for (const pending of atlasCache.values()) pending.then((image) => {
+				image.close?.();
+			});
+			atlasCache.clear();
+			atlasReady.clear();
+			dbPromises.clear();
+			dbReady.clear();
+			manifestPromise = void 0;
+			manifestReady = false;
+			fontsPromise = void 0;
+		}
+	};
+}
+//#endregion
+//#region src/frame.ts
+/**
+* Tile-aligned viewport from draw-list visual bounds, optionally plus `padTiles`
+* on each side. Visual bounds already include sprite overhang, shadows, and wires;
+* `padTiles` defaults to 0 in the renderer. All edges are integers so the canvas is
+* an exact multiple of `pixelsPerTile` with no fragmented checker cells.
+*/
+function computeTileFrame(bounds, padTiles) {
+	return {
+		minX: Math.floor(bounds.minX) - padTiles,
+		minY: Math.floor(bounds.minY) - padTiles,
+		maxX: Math.ceil(bounds.maxX) + padTiles,
+		maxY: Math.ceil(bounds.maxY) + padTiles
+	};
+}
+//#endregion
+//#region src/png-stream.ts
+const PNG_SIGNATURE = new Uint8Array([
+	137,
+	80,
+	78,
+	71,
+	13,
+	10,
+	26,
+	10
+]);
+const PNG_MAX_DIMENSION = 2147483647;
+const crcTable = (() => {
+	const table = /* @__PURE__ */ new Uint32Array(256);
+	for (let i = 0; i < table.length; i++) {
+		let value = i;
+		for (let bit = 0; bit < 8; bit++) value = value & 1 ? 3988292384 ^ value >>> 1 : value >>> 1;
+		table[i] = value >>> 0;
+	}
+	return table;
+})();
+function writeUint32(target, offset, value) {
+	target[offset] = value >>> 24 & 255;
+	target[offset + 1] = value >>> 16 & 255;
+	target[offset + 2] = value >>> 8 & 255;
+	target[offset + 3] = value & 255;
+}
+function crc32(type, data) {
+	let crc = 4294967295;
+	for (const bytes of [type, data]) for (const byte of bytes) crc = (crcTable[(crc ^ byte) & 255] ?? 0) ^ crc >>> 8;
+	return (crc ^ 4294967295) >>> 0;
+}
+function pngChunk(type, data = /* @__PURE__ */ new Uint8Array()) {
+	const typeBytes = new TextEncoder().encode(type);
+	const chunk = new Uint8Array(12 + data.length);
+	writeUint32(chunk, 0, data.length);
+	chunk.set(typeBytes, 4);
+	chunk.set(data, 8);
+	writeUint32(chunk, 8 + data.length, crc32(typeBytes, data));
+	return chunk;
+}
+const blobPart = (bytes) => bytes.slice().buffer;
+/**
+* Incremental 8-bit RGBA PNG encoder. Only compressed PNG chunks are retained;
+* callers control raw working memory by choosing how many rows to submit.
+*/
+function createStreamingPngEncoder(width, height) {
+	if (!Number.isInteger(width) || width <= 0 || width > PNG_MAX_DIMENSION) throw new Error(`PNG width must be an integer between 1 and ${PNG_MAX_DIMENSION}`);
+	if (!Number.isInteger(height) || height <= 0 || height > PNG_MAX_DIMENSION) throw new Error(`PNG height must be an integer between 1 and ${PNG_MAX_DIMENSION}`);
+	const ihdr = /* @__PURE__ */ new Uint8Array(13);
+	writeUint32(ihdr, 0, width);
+	writeUint32(ihdr, 4, height);
+	ihdr[8] = 8;
+	ihdr[9] = 6;
+	const chunks = [blobPart(PNG_SIGNATURE), blobPart(pngChunk("IHDR", ihdr))];
+	let rowsWritten = 0;
+	let finished = false;
+	const zlib = new Zlib({ level: 6 }, (data) => {
+		if (data.length > 0) chunks.push(blobPart(pngChunk("IDAT", data)));
+	});
+	return {
+		width,
+		height,
+		get rowsWritten() {
+			return rowsWritten;
+		},
+		writeRgbaRows(rgba, rowCount) {
+			if (finished) throw new Error("PNG encoder is already finished");
+			if (!Number.isInteger(rowCount) || rowCount <= 0 || rowsWritten + rowCount > height) throw new Error("PNG row count exceeds the declared image height");
+			const rgbaStride = width * 4;
+			if (rgba.length !== rgbaStride * rowCount) throw new Error(`Expected ${rgbaStride * rowCount} RGBA bytes for ${rowCount} rows, got ${rgba.length}`);
+			const scanlines = new Uint8Array((rgbaStride + 1) * rowCount);
+			for (let row = 0; row < rowCount; row++) {
+				const sourceStart = row * rgbaStride;
+				const targetStart = row * (rgbaStride + 1) + 1;
+				scanlines.set(rgba.subarray(sourceStart, sourceStart + rgbaStride), targetStart);
+			}
+			rowsWritten += rowCount;
+			zlib.push(scanlines, rowsWritten === height);
+		},
+		finish() {
+			if (finished) throw new Error("PNG encoder is already finished");
+			if (rowsWritten !== height) throw new Error(`PNG is incomplete: wrote ${rowsWritten} of ${height} rows`);
+			finished = true;
+			chunks.push(blobPart(pngChunk("IEND")));
+			return new Blob(chunks, { type: "image/png" });
+		}
+	};
+}
+//#endregion
+//#region src/background.ts
+var UnknownTerrainBackgroundError = class extends Error {
+	name = "UnknownTerrainBackgroundError";
+	terrainName;
+	constructor(terrainName) {
+		super(`Unknown terrain background "${terrainName}"`);
+		this.terrainName = terrainName;
+	}
+};
+var AssetDensityMismatchError = class extends Error {
+	name = "AssetDensityMismatchError";
+	tier;
+	expectedDensity;
+	actualDensity;
+	constructor(tier, expectedDensity, actualDensity) {
+		super(`Render DB assetDensity ${actualDensity ?? "undefined"} does not match asset tier ${tier} (expected ${expectedDensity})`);
+		this.tier = tier;
+		this.expectedDensity = expectedDensity;
+		this.actualDensity = actualDensity;
+	}
+};
+function resolveBackground(prefersPlatformGraphics, background) {
+	const mode = background ?? { type: "none" };
+	switch (mode.type) {
+		case "none": return {
+			solid: null,
+			showCheckerboard: false,
+			showSpace: false,
+			showSpacePlanet: false
+		};
+		case "solid": return {
+			solid: mode.color,
+			showCheckerboard: false,
+			showSpace: false,
+			showSpacePlanet: false
+		};
+		case "checkerboard": return {
+			solid: null,
+			showCheckerboard: true,
+			showSpace: false,
+			showSpacePlanet: false
+		};
+		case "space": return {
+			solid: null,
+			showCheckerboard: false,
+			showSpace: true,
+			showSpacePlanet: mode.planet === true,
+			spacePlanet: mode.planetName
+		};
+		case "terrain": return {
+			solid: null,
+			showCheckerboard: false,
+			showSpace: false,
+			showSpacePlanet: false,
+			terrainName: mode.name
+		};
+		case "auto": {
+			const useSpace = prefersPlatformGraphics;
+			return {
+				solid: null,
+				showCheckerboard: !useSpace,
+				showSpace: useSpace,
+				showSpacePlanet: false
+			};
+		}
+		default: return mode;
+	}
+}
+//#endregion
+//#region src/renderer.ts
+function finitePositive(value, label) {
+	if (!Number.isFinite(value) || value <= 0) throw new Error(`${label} must be a finite number greater than zero`);
+	return value;
+}
+function measureTileFrame(tileFrame, requestedPixelsPerTile, maxOutputSize) {
+	const requested = finitePositive(requestedPixelsPerTile, "pixelsPerTile");
+	const tilesWide = Math.max(0, tileFrame.maxX - tileFrame.minX);
+	const tilesHigh = Math.max(0, tileFrame.maxY - tileFrame.minY);
+	const requestedWidth = Math.max(1, Math.floor(tilesWide * requested));
+	const requestedHeight = Math.max(1, Math.floor(tilesHigh * requested));
+	let pixelsPerTile = requested;
+	if (maxOutputSize) {
+		const maxWidth = finitePositive(maxOutputSize.width, "maxOutputSize.width");
+		const maxHeight = finitePositive(maxOutputSize.height, "maxOutputSize.height");
+		if (tilesWide > 0) pixelsPerTile = Math.min(pixelsPerTile, maxWidth / tilesWide);
+		if (tilesHigh > 0) pixelsPerTile = Math.min(pixelsPerTile, maxHeight / tilesHigh);
+	}
+	const width = Math.max(1, Math.floor(tilesWide * pixelsPerTile));
+	const height = Math.max(1, Math.floor(tilesHigh * pixelsPerTile));
+	return {
+		tileFrame,
+		requestedPixelsPerTile: requested,
+		pixelsPerTile,
+		requestedWidth,
+		requestedHeight,
+		width,
+		height,
+		capped: pixelsPerTile < requested
+	};
+}
+function isBlueprint(value) {
+	return value.item === "blueprint";
+}
+function trySelectUpgradePlanner(doc, path) {
+	try {
+		return selectUpgradePlanner(doc, path);
+	} catch {
+		return null;
+	}
+}
+function trySelectDeconstructionPlanner(doc, path) {
+	try {
+		return selectDeconstructionPlanner(doc, path);
+	} catch {
+		return null;
+	}
+}
+/** Resolve Auto background into concrete checkerboard / space flags. */
+function resolveBackgroundOpts(bp, background) {
+	return resolveBackground(bp ? blueprintPrefersPlatformGraphics(bp) : false, background);
+}
+function planDocumentDrawList(docOrBlueprint, db, opts) {
+	if (isBlueprint(docOrBlueprint)) return {
+		blueprint: docOrBlueprint,
+		drawList: planDrawListInternal(docOrBlueprint, db, {
+			altMode: opts.altMode,
+			beltEndings: opts.beltEndings,
+			profileOut: opts.profileOut
+		}).drawList
+	};
+	const planner = trySelectUpgradePlanner(docOrBlueprint, opts.blueprintPath);
+	if (planner) return {
+		blueprint: null,
+		drawList: planUpgradePlannerDrawList(planner, db)
+	};
+	const deconstruction = trySelectDeconstructionPlanner(docOrBlueprint, opts.blueprintPath);
+	if (deconstruction) return {
+		blueprint: null,
+		drawList: planDeconstructionPlannerDrawList(deconstruction, db)
+	};
+	const blueprint = selectBlueprint(docOrBlueprint, opts.blueprintPath);
+	return {
+		blueprint,
+		drawList: planDrawListInternal(blueprint, db, {
+			altMode: opts.altMode,
+			beltEndings: opts.beltEndings,
+			profileOut: opts.profileOut
+		}).drawList
+	};
+}
+function defaultCreateCanvas(width, height) {
+	if (typeof OffscreenCanvas !== "undefined") return new OffscreenCanvas(width, height);
+	if (typeof document !== "undefined" && typeof document.createElement === "function") {
+		const el = document.createElement("canvas");
+		el.width = width;
+		el.height = height;
+		return el;
+	}
+	throw new Error("No canvas factory available. In Node, pass createCanvas from skia-canvas (e.g. createRenderer({ assets, createCanvas: (w, h) => new Canvas(w, h) })) or use fpsr/node helpers.");
+}
+async function encodeCanvasBlob(canvas, options = {}) {
+	const type = options.type ?? "image/png";
+	let blob;
+	if (typeof canvas.convertToBlob === "function") blob = await canvas.convertToBlob({
+		type,
+		quality: options.quality
+	});
+	else {
+		const htmlCanvas = canvas;
+		if (typeof htmlCanvas.toBlob !== "function") throw new Error("Canvas does not support image blob encoding; use OffscreenCanvas or HTMLCanvasElement.");
+		blob = await new Promise((resolve, reject) => {
+			htmlCanvas.toBlob((encoded) => {
+				if (encoded) resolve(encoded);
+				else reject(/* @__PURE__ */ new Error("canvas.toBlob returned null"));
+			}, type, options.quality);
+		});
+	}
+	if (blob.type !== type) throw new Error(`Canvas encoder does not support ${type}; returned ${blob.type || "unknown"}`);
+	return blob;
+}
+async function encodeCanvasBuffer(canvas, options = {}) {
+	const type = options.type ?? "image/png";
+	if (typeof canvas.toBuffer === "function") {
+		const buffer = await canvas.toBuffer(type, { quality: options.quality });
+		return buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
+	}
+	const blob = await encodeCanvasBlob(canvas, options);
+	return new Uint8Array(await blob.arrayBuffer());
+}
+function collectAtlasIndices(list, db, terrainBackground, spacePlanetFrameId) {
+	const set = /* @__PURE__ */ new Set();
+	for (const cmd of list.commands) if (cmd.kind === "sprite" || cmd.kind === "icon") {
+		const frame = db.frames[cmd.frame];
+		if (frame) set.add(frame.a);
+		if (cmd.kind === "icon" && cmd.backingFrame != null) {
+			const backing = db.frames[cmd.backingFrame];
+			if (backing) set.add(backing.a);
+		}
+	}
+	for (const frameId of terrainBackground?.frames ?? []) {
+		const frame = db.frames[frameId];
+		if (frame) set.add(frame.a);
+	}
+	for (const patch of terrainBackground?.patches ?? []) for (const frameId of patch.frames) {
+		const frame = db.frames[frameId];
+		if (frame) set.add(frame.a);
+	}
+	if (spacePlanetFrameId != null) {
+		const frame = db.frames[spacePlanetFrameId];
+		if (frame) set.add(frame.a);
+	}
+	return [...set].sort((a, b) => a - b);
+}
+function selectTerrainBackground(db, terrainName) {
+	if (terrainName == null) return void 0;
+	const background = db.terrainBackgrounds?.[terrainName];
+	if (!background) throw new UnknownTerrainBackgroundError(terrainName);
+	return background;
+}
+/** Resolve the starmap frame for an optional planet prototype name. */
+function resolveSpacePlanetFrameId(spaceBackground, spacePlanet) {
+	if (!spaceBackground) return void 0;
+	if (spacePlanet != null) {
+		const named = spaceBackground.planets?.[spacePlanet];
+		if (named != null) return named;
+	}
+	return spaceBackground.planetFrame;
+}
+function selectSpaceBackground(db, resolved) {
+	if (!resolved.showSpace || !resolved.showSpacePlanet || !db.spaceBackground) return void 0;
+	const planetFrame = resolveSpacePlanetFrameId(db.spaceBackground, resolved.spacePlanet);
+	if (planetFrame == null) return void 0;
+	return {
+		...db.spaceBackground,
+		planetFrame
+	};
+}
+function summarizeDrawList(list, atlasIndices) {
+	const byKind = {};
+	const layerHistogram = {};
+	const frames = /* @__PURE__ */ new Set();
+	for (const cmd of list.commands) {
+		byKind[cmd.kind] = (byKind[cmd.kind] ?? 0) + 1;
+		const layerKey = String(cmd.layer);
+		layerHistogram[layerKey] = (layerHistogram[layerKey] ?? 0) + 1;
+		if (cmd.kind === "sprite" || cmd.kind === "icon") {
+			frames.add(cmd.frame);
+			if (cmd.kind === "icon" && cmd.backingFrame != null) frames.add(cmd.backingFrame);
+		}
+	}
+	return {
+		commandCount: list.commands.length,
+		byKind,
+		uniqueFrames: frames.size,
+		layerHistogram,
+		atlasIndices
+	};
+}
+function emptyPlanProfile() {
+	return {
+		migrateMs: 0,
+		resolveMs: 0,
+		tilesMs: 0,
+		entitiesMs: 0,
+		overlaysMs: 0,
+		sortMs: 0,
+		totalMs: 0
+	};
+}
+function throwIfAborted(signal) {
+	throwIfAborted$1(signal, "Render aborted");
+}
+/**
+* Internal registry so tiled/viewer hosts can paint prepared viewports without
+* exposing that method on the stable {@link Renderer} type.
+*/
+const preparedViewportByRenderer = /* @__PURE__ */ new WeakMap();
+function reportProgress(opts, event) {
+	if (!opts.signal?.aborted) opts.onProgress?.(event);
+}
+/**
+* Create a renderer that loads the render-db once and lazily loads atlases
+* referenced by each draw list.
+*/
+async function createRenderer(options) {
+	const { assets } = options;
+	const assetTier = options.assetTier ?? "2x";
+	const createCanvas = options.createCanvas ?? defaultCreateCanvas;
+	const db = options.renderDb ?? await assets.loadRenderDb(assetTier);
+	const expectedDensity = assetTier === "1x" ? 1 : 2;
+	if (db.assetDensity != null && db.assetDensity !== expectedDensity) throw new AssetDensityMismatchError(assetTier, expectedDensity, db.assetDensity);
+	await assets.ensureFonts?.();
+	const atlasCache = /* @__PURE__ */ new Map();
+	const iconImageCache = /* @__PURE__ */ new Map();
+	const silhouetteImageCache = /* @__PURE__ */ new Map();
+	/**
+	* Cache only signal-independent shared atlas promises. Per-caller abort is
+	* applied via {@link raceWithAbort} so concurrent renders are not coupled.
+	*/
+	const loadAtlas = (index, signal) => {
+		let pending = atlasCache.get(index);
+		if (!pending) {
+			pending = assets.loadAtlasImage(index, assetTier).catch((error) => {
+				atlasCache.delete(index);
+				throw error;
+			});
+			atlasCache.set(index, pending);
+		}
+		return raceWithAbort(pending, signal);
+	};
+	/** Shared paint path for both a fresh plan (`render`) and a prepared viewport. */
+	async function paint(docOrBlueprint, opts) {
+		throwIfAborted(opts.signal);
+		const wantProfile = opts.profile === true;
+		const tTotal = wantProfile ? nowMs() : 0;
+		if (wantProfile) perfMark("fpsr-render-start");
+		let t = wantProfile ? nowMs() : 0;
+		const planProfile = wantProfile ? emptyPlanProfile() : void 0;
+		reportProgress(opts, { stage: "planning" });
+		if (wantProfile) perfMark("fpsr-plan-start");
+		let bp;
+		let drawList;
+		if (opts.preparedDrawList !== void 0) {
+			drawList = opts.preparedDrawList;
+			if (isBlueprint(docOrBlueprint)) bp = docOrBlueprint;
+			else try {
+				bp = selectBlueprint(docOrBlueprint, opts.blueprintPath);
+			} catch {
+				bp = null;
+			}
+		} else {
+			const planned = planDocumentDrawList(docOrBlueprint, db, {
+				blueprintPath: opts.blueprintPath,
+				altMode: opts.altMode,
+				beltEndings: opts.beltEndings,
+				profileOut: planProfile
+			});
+			bp = planned.blueprint;
+			drawList = planned.drawList;
+		}
+		const selectMs = wantProfile ? nowMs() - t : 0;
+		const bg = resolveBackgroundOpts(bp, opts.background);
+		const requestedPixelsPerTile = opts.pixelsPerTile ?? 64;
+		const padTiles = opts.padTiles ?? 0;
+		throwIfAborted(opts.signal);
+		if (wantProfile) {
+			perfMark("fpsr-plan-end");
+			perfMeasure("fpsr-plan", "fpsr-plan-start", "fpsr-plan-end");
+		}
+		const terrainBackground = selectTerrainBackground(db, bg.terrainName);
+		const spaceBackground = selectSpaceBackground(db, bg);
+		const atlasIndices = collectAtlasIndices(drawList, db, terrainBackground, spaceBackground?.planetFrame);
+		const assetEvents = [];
+		let loadedAtlasCount = 0;
+		reportProgress(opts, {
+			stage: "loading-assets",
+			completed: loadedAtlasCount,
+			total: atlasIndices.length
+		});
+		if (wantProfile) perfMark("fpsr-assets-start");
+		const tAssets = wantProfile ? nowMs() : 0;
+		const loaded = await Promise.all(atlasIndices.map(async (i) => {
+			const cached = atlasCache.has(i);
+			const tAtlas = wantProfile ? nowMs() : 0;
+			const img = await loadAtlas(i, opts.signal);
+			loadedAtlasCount++;
+			reportProgress(opts, {
+				stage: "loading-assets",
+				completed: loadedAtlasCount,
+				total: atlasIndices.length
+			});
+			if (wantProfile) {
+				const atlas = db.atlases[i];
+				assetEvents.push({
+					kind: "atlas",
+					index: i,
+					tier: assetTier,
+					cached,
+					decodedPixels: atlas ? atlas.width * atlas.height : void 0,
+					totalMs: nowMs() - tAtlas
+				});
+			}
+			return img;
+		}));
+		const assetsMs = wantProfile ? nowMs() - tAssets : 0;
+		throwIfAborted(opts.signal);
+		if (wantProfile) {
+			perfMark("fpsr-assets-end");
+			perfMeasure("fpsr-assets", "fpsr-assets-start", "fpsr-assets-end");
+		}
+		const images = [];
+		for (let i = 0; i < atlasIndices.length; i++) {
+			const idx = atlasIndices[i];
+			const img = loaded[i];
+			if (idx !== void 0 && img !== void 0) images[idx] = img;
+		}
+		t = wantProfile ? nowMs() : 0;
+		reportProgress(opts, { stage: "baking-icons" });
+		const iconImages = /* @__PURE__ */ new Map();
+		const iconImageData = /* @__PURE__ */ new Map();
+		const silhouetteImages = /* @__PURE__ */ new Map();
+		const seenIconKeys = /* @__PURE__ */ new Set();
+		const seenSilhouetteKeys = /* @__PURE__ */ new Set();
+		let iconCacheHits = 0;
+		let iconCacheMisses = 0;
+		let silhouetteCacheHits = 0;
+		let silhouetteCacheMisses = 0;
+		for (const cmd of drawList.commands) {
+			if (cmd.kind !== "icon" || cmd.backingFrame == null && cmd.backing !== true && cmd.silhouette !== true) continue;
+			const frame = db.frames[cmd.frame];
+			const atlasImage = frame ? images[frame.a] : void 0;
+			if (!frame || !atlasImage || frame.w <= 0 || frame.h <= 0) continue;
+			const packedWidth = frame.pw ?? frame.w;
+			const packedHeight = frame.ph ?? frame.h;
+			const iconKey = `${assetTier}:${cmd.frame}:${packedWidth}x${packedHeight}`;
+			const cachedIcon = iconImageCache.get(iconKey);
+			if (!seenIconKeys.has(iconKey)) {
+				seenIconKeys.add(iconKey);
+				if (cachedIcon) iconCacheHits++;
+			}
+			if (cachedIcon) iconImages.set(cmd.frame, cachedIcon);
+			else if (!iconImages.has(cmd.frame)) {
+				const iconCanvas = createCanvas(packedWidth, packedHeight);
+				iconCanvas.width = packedWidth;
+				iconCanvas.height = packedHeight;
+				const iconContext = iconCanvas.getContext("2d");
+				if (!iconContext) continue;
+				iconContext.drawImage(atlasImage, frame.x, frame.y, packedWidth, packedHeight, 0, 0, packedWidth, packedHeight);
+				const image = iconCanvas;
+				iconImages.set(cmd.frame, image);
+				iconImageCache.set(iconKey, image);
+				const readableContext = iconContext;
+				if (cmd.backingStyle !== "request-pin" && typeof readableContext.getImageData === "function") iconImageData.set(cmd.frame, readableContext.getImageData(0, 0, packedWidth, packedHeight));
+				iconCacheMisses++;
+			}
+			if (cmd.backingStyle === "request-pin" || silhouetteImages.has(cmd.frame)) continue;
+			const densityScale = (db.assetDensity ?? 2) / 2;
+			const dilateRadius = Math.max(1, Math.round(12 * densityScale));
+			const blurRadius = Math.max(1, Math.round(16 * densityScale));
+			const silhouetteKey = `${iconKey}:${dilateRadius}:${blurRadius}`;
+			const cachedSilhouette = silhouetteImageCache.get(silhouetteKey);
+			if (!seenSilhouetteKeys.has(silhouetteKey)) {
+				seenSilhouetteKeys.add(silhouetteKey);
+				if (cachedSilhouette) silhouetteCacheHits++;
+			}
+			if (cachedSilhouette) {
+				silhouetteImages.set(cmd.frame, cachedSilhouette);
+				continue;
+			}
+			const iconSource = iconImages.get(cmd.frame);
+			if (!iconSource) continue;
+			const sourceData = iconImageData.get(cmd.frame);
+			const silhouette = sourceData ? bakeEntityInfoSilhouetteFromImageData(sourceData, createCanvas, dilateRadius, blurRadius) : bakeEntityInfoSilhouette(iconSource, packedWidth, packedHeight, createCanvas, dilateRadius, blurRadius);
+			if (silhouette) {
+				silhouetteImages.set(cmd.frame, silhouette);
+				silhouetteImageCache.set(silhouetteKey, silhouette);
+				silhouetteCacheMisses++;
+			}
+		}
+		const iconBakeMs = wantProfile ? nowMs() - t : 0;
+		t = wantProfile ? nowMs() : 0;
+		const outputTileFrame = opts.outputTileFrame ?? computeTileFrame(drawList.bounds, padTiles);
+		const tileFrame = opts.tileFrame ?? outputTileFrame;
+		if (tileFrame.minX < outputTileFrame.minX || tileFrame.minY < outputTileFrame.minY || tileFrame.maxX > outputTileFrame.maxX || tileFrame.maxY > outputTileFrame.maxY || tileFrame.minX >= tileFrame.maxX || tileFrame.minY >= tileFrame.maxY) throw new Error("tileFrame must be a non-empty viewport inside outputTileFrame");
+		const output = measureTileFrame(tileFrame, requestedPixelsPerTile, opts.maxOutputSize);
+		const { width, height, pixelsPerTile } = output;
+		throwIfAborted(opts.signal);
+		const canvas = opts.canvas ?? createCanvas(width, height);
+		canvas.width = width;
+		canvas.height = height;
+		const ctx = canvas.getContext("2d");
+		if (!ctx) throw new Error("Failed to acquire 2d canvas context");
+		const frameMs = wantProfile ? nowMs() - t : 0;
+		if (wantProfile) perfMark("fpsr-paint-start");
+		reportProgress(opts, { stage: "painting" });
+		t = wantProfile ? nowMs() : 0;
+		const paintStats = {
+			shadowRuns: 0,
+			shadowTiles: 0,
+			shadowCompositedPixels: 0,
+			shadowPeakScratchPixels: 0
+		};
+		executeDrawList(ctx, opts.tileFrame ? drawListForTile(drawList, db.frames, tileFrame) : drawList, images, {
+			pixelsPerTile,
+			padTiles,
+			tileFrame,
+			outputTileFrame,
+			background: bg.solid,
+			showCheckerboard: bg.showCheckerboard,
+			showSpace: bg.showSpace,
+			terrainBackground,
+			spaceBackground,
+			showCoordinates: opts.showCoordinates,
+			frames: db.frames,
+			iconImages,
+			silhouetteImages,
+			createCanvas,
+			stats: paintStats
+		});
+		const paintMs = wantProfile ? nowMs() - t : 0;
+		if (wantProfile) {
+			perfMark("fpsr-paint-end");
+			perfMeasure("fpsr-paint", "fpsr-paint-start", "fpsr-paint-end");
+			perfMark("fpsr-render-end");
+			perfMeasure("fpsr-render", "fpsr-render-start", "fpsr-render-end");
+		}
+		const profile = wantProfile ? {
+			selectMs,
+			plan: planProfile ?? emptyPlanProfile(),
+			assets: assetEvents,
+			assetsMs,
+			iconBakeMs,
+			iconBakeCount: iconImages.size,
+			silhouetteBakeCount: silhouetteImages.size,
+			iconCacheHits,
+			iconCacheMisses,
+			silhouetteCacheHits,
+			silhouetteCacheMisses,
+			frameMs,
+			paintMs,
+			shadow: {
+				runs: paintStats.shadowRuns,
+				tiles: paintStats.shadowTiles,
+				compositedPixels: paintStats.shadowCompositedPixels,
+				peakScratchPixels: paintStats.shadowPeakScratchPixels
+			},
+			totalMs: nowMs() - tTotal,
+			cold: assetEvents.some((e) => !e.cached),
+			drawList: summarizeDrawList(drawList, atlasIndices),
+			output: {
+				width,
+				height,
+				megapixels: width * height / 1e6,
+				pixelsPerTile,
+				requestedPixelsPerTile,
+				capped: output.capped,
+				assetTier,
+				tileFrame
+			},
+			db: {
+				entityDefs: Object.keys(db.entities).length,
+				tileDefs: Object.keys(db.tiles).length,
+				frameCount: db.frames.length,
+				atlasCount: db.atlases.length
+			}
+		} : void 0;
+		reportProgress(opts, { stage: "complete" });
+		return {
+			canvas,
+			width,
+			height,
+			drawList,
+			tileFrame,
+			profile,
+			toImageBlob(options) {
+				return encodeCanvasBlob(canvas, options);
+			},
+			toImageBuffer(options) {
+				return encodeCanvasBuffer(canvas, options);
+			},
+			async toPngBlob() {
+				return encodeCanvasBlob(canvas, { type: "image/png" });
+			},
+			async toPngBuffer() {
+				return encodeCanvasBuffer(canvas, { type: "image/png" });
+			}
+		};
+	}
+	const renderer = {
+		measure(docOrBlueprint, opts = {}) {
+			throwIfAborted(opts.signal);
+			const { drawList } = planDocumentDrawList(docOrBlueprint, db, {
+				blueprintPath: opts.blueprintPath,
+				altMode: opts.altMode,
+				beltEndings: opts.beltEndings
+			});
+			throwIfAborted(opts.signal);
+			return measureTileFrame(computeTileFrame(drawList.bounds, opts.padTiles ?? 0), opts.pixelsPerTile ?? 64, opts.maxOutputSize);
+		},
+		render(docOrBlueprint, opts = {}) {
+			return paint(docOrBlueprint, opts);
+		},
+		async renderTiledPng(docOrBlueprint, opts = {}) {
+			throwIfAborted(opts.signal);
+			const pixelsPerTile = opts.pixelsPerTile ?? 64;
+			if (!Number.isInteger(pixelsPerTile) || pixelsPerTile <= 0) throw new Error("Tiled PNG export requires an integer pixelsPerTile greater than zero");
+			reportProgress(opts, { stage: "planning" });
+			const { drawList: preparedDrawList } = planDocumentDrawList(docOrBlueprint, db, {
+				blueprintPath: opts.blueprintPath,
+				altMode: opts.altMode,
+				beltEndings: opts.beltEndings
+			});
+			const padTiles = opts.padTiles ?? 0;
+			const tileFrame = computeTileFrame(preparedDrawList.bounds, padTiles);
+			const { width, height } = measureTileFrame(tileFrame, pixelsPerTile);
+			const tileSize = Math.max(pixelsPerTile, Math.floor(opts.tileSize ?? 2048));
+			const maxPaintTileEdge = Math.max(1, Math.floor(tileSize / pixelsPerTile));
+			const viewportBleedTiles = Math.min(2, Math.max(0, Math.floor((maxPaintTileEdge - 1) / 2)));
+			const chunkTileWidth = Math.max(1, maxPaintTileEdge - viewportBleedTiles * 2);
+			const maxStripeBytes = Math.max(width * pixelsPerTile * 4, opts.maxStripeBytes ?? 32 * 1024 * 1024);
+			const maxStripePixelRows = Math.max(pixelsPerTile, Math.floor(maxStripeBytes / Math.max(1, width * 4) / pixelsPerTile) * pixelsPerTile);
+			const stripTileHeight = Math.max(1, Math.min(chunkTileWidth, Math.floor(maxStripePixelRows / pixelsPerTile)));
+			const totalTiles = Math.ceil((tileFrame.maxX - tileFrame.minX) / chunkTileWidth) * Math.ceil((tileFrame.maxY - tileFrame.minY) / stripTileHeight);
+			const encoder = createStreamingPngEncoder(width, height);
+			let completedTiles = 0;
+			const { tileSize: _tileSize, maxStripeBytes: _maxStripeBytes, ...renderOpts } = opts;
+			for (let minY = tileFrame.minY; minY < tileFrame.maxY; minY += stripTileHeight) {
+				throwIfAborted(opts.signal);
+				const maxY = Math.min(tileFrame.maxY, minY + stripTileHeight);
+				const stripHeight = (maxY - minY) * pixelsPerTile;
+				const strip = new Uint8Array(width * stripHeight * 4);
+				for (let minX = tileFrame.minX; minX < tileFrame.maxX; minX += chunkTileWidth) {
+					throwIfAborted(opts.signal);
+					const maxX = Math.min(tileFrame.maxX, minX + chunkTileWidth);
+					const paintRegion = {
+						minX: Math.max(tileFrame.minX, minX - viewportBleedTiles),
+						minY: Math.max(tileFrame.minY, minY - viewportBleedTiles),
+						maxX: Math.min(tileFrame.maxX, maxX + viewportBleedTiles),
+						maxY: Math.min(tileFrame.maxY, maxY + viewportBleedTiles)
+					};
+					const regionDrawList = drawListForTile(preparedDrawList, db.frames, paintRegion);
+					const context = (await paint(docOrBlueprint, {
+						...renderOpts,
+						pixelsPerTile,
+						profile: false,
+						tileFrame: paintRegion,
+						outputTileFrame: tileFrame,
+						preparedDrawList: regionDrawList,
+						onProgress: void 0
+					})).canvas.getContext("2d");
+					if (!context || typeof context.getImageData !== "function") throw new Error("Tiled PNG export requires Canvas2D getImageData support");
+					const sourceX = (minX - paintRegion.minX) * pixelsPerTile;
+					const sourceY = (minY - paintRegion.minY) * pixelsPerTile;
+					const regionWidth = (maxX - minX) * pixelsPerTile;
+					const regionHeight = (maxY - minY) * pixelsPerTile;
+					const pixels = context.getImageData(sourceX, sourceY, regionWidth, regionHeight).data;
+					const destinationX = (minX - tileFrame.minX) * pixelsPerTile;
+					for (let row = 0; row < regionHeight; row++) {
+						const sourceStart = row * regionWidth * 4;
+						const destinationStart = (row * width + destinationX) * 4;
+						strip.set(pixels.subarray(sourceStart, sourceStart + regionWidth * 4), destinationStart);
+					}
+					completedTiles++;
+					reportProgress(opts, {
+						stage: "painting-tiles",
+						completed: completedTiles,
+						total: totalTiles
+					});
+				}
+				encoder.writeRgbaRows(strip, stripHeight);
+			}
+			reportProgress(opts, { stage: "encoding" });
+			const blob = encoder.finish();
+			reportProgress(opts, { stage: "complete" });
+			return {
+				blob,
+				width,
+				height,
+				tileFrame,
+				tiled: true
+			};
+		},
+		dispose() {
+			iconImageCache.clear();
+			silhouetteImageCache.clear();
+			atlasCache.clear();
+		}
+	};
+	preparedViewportByRenderer.set(renderer, (docOrBlueprint, opts) => paint(docOrBlueprint, opts));
+	return renderer;
+}
+//#endregion
+export { AssetDensityMismatchError, BLUEPRINT_ADAPTERS, BLUEPRINT_ICON_TILE_SIZE, BlueprintDecodeError, BlueprintSelectError, DECONSTRUCTION_ENTITY_FILTER_SLOT_COUNT, DECONSTRUCTION_PLANNER_COLUMNS, DECONSTRUCTION_TILE_FILTER_SLOT_COUNT, FPSR_TEXT_FONT_FALLBACK, FPSR_TEXT_FONT_FAMILY, UPGRADE_PLANNER_COLUMNS, UPGRADE_PLANNER_SLOT_COUNT, UnknownTerrainBackgroundError, asDeconstructionPlanner, asUpgradePlanner, blueprintBookCover, blueprintBookCoverIcons, blueprintIconSignalCenter, blueprintIconSignalScale, blueprintIconSignalSizePx, blueprintIconSignalYOffsetPx, buildBookTree, cdnAssets, computeTileFrame, countBlueprintComponents, createRenderer, createStreamingPngEncoder, decode, decodeVersion, decodeWithStats, deconstructionEntityFilterMode, deconstructionEntityFilters, deconstructionPlannerIcons, deconstructionTileFilterMode, deconstructionTileFilters, deconstructionTileSelectionMode, deconstructionTreesAndRocksOnly, encode, filledBlueprintIcons, formatDeconstructionFilterMode, formatDeconstructionTileSelectionMode, fpsrTextFontCss, legacyItemsObjectToInsertPlans, listBlueprints, measureTileFrame, migrateDocumentTo2x, migrateTo2x, parseRichText, planBlueprintIcons, planDeconstructionPlannerDrawList, planUpgradePlannerDrawList, resolveActivePath, resolveIconFrameId, resolveSpacePlanetFrameId, richTextIconKeys, richTextIconQuality, selectBlueprint, selectBook, selectDeconstructionPlanner, selectUpgradePlanner, stripRichText, upgradePlannerIcons, upgradePlannerMappers };
+
+//# sourceMappingURL=index.js.map