@rickyzhangca/fpsr 0.0.1

package/dist/execute-CRZV5zw1.js

@@ -0,0 +1,963 @@
+import { S as RENDER_LAYERS, o as TRAIN_CHAIN_JOINT_RADIUS, p as entityInfoSilhouettePadPx } from "./profile-DR4i6HDp.js";
+//#region src/text-font.ts
+/** CSS / canvas font-family registered from pipeline DejaVuSans.ttf. */
+const FPSR_TEXT_FONT_FAMILY = "fpsr-dejavu";
+/** Fallback stack when the bundled TTF is unavailable. */
+const FPSR_TEXT_FONT_FALLBACK = "DejaVu Sans, sans-serif";
+function fpsrTextFontCss(sizePx) {
+	return `${sizePx}px ${FPSR_TEXT_FONT_FAMILY}, ${FPSR_TEXT_FONT_FALLBACK}`;
+}
+//#endregion
+//#region src/checkerboard.ts
+const TILE_LIGHT = "#1a1a1a";
+const TILE_DARK = "#252525";
+/** Fill `width`×`height` with an axis-aligned checkerboard; one cell = `pixelsPerTile` px. */
+function drawTileCheckerboard(ctx, width, height, pixelsPerTile, tileOffsetX = 0, tileOffsetY = 0) {
+	const ppt = Math.max(1, pixelsPerTile);
+	const columns = Math.ceil(width / ppt);
+	const rows = Math.ceil(height / ppt);
+	for (let cellY = 0; cellY < rows; cellY++) {
+		const y = cellY * ppt;
+		for (let cellX = 0; cellX < columns; cellX++) {
+			const x = cellX * ppt;
+			ctx.fillStyle = (cellX + tileOffsetX + cellY + tileOffsetY) % 2 === 0 ? TILE_DARK : TILE_LIGHT;
+			ctx.fillRect(x, y, Math.min(ppt, width - x), Math.min(ppt, height - y));
+		}
+	}
+}
+/** Paint an image on top of a tile-aligned checkerboard (for external reference PNGs). */
+function blitWithTileCheckerboard(canvas, image, width, height, pixelsPerTile) {
+	canvas.width = width;
+	canvas.height = height;
+	const ctx = canvas.getContext("2d");
+	if (!ctx) return;
+	drawTileCheckerboard(ctx, width, height, pixelsPerTile);
+	ctx.imageSmoothingEnabled = false;
+	ctx.drawImage(image, 0, 0, width, height);
+}
+//#endregion
+//#region src/coordinate-overlay.ts
+const GRID_STROKE = "rgba(255, 255, 255, 0.28)";
+const LABEL_FILL = "rgba(255, 255, 255, 0.85)";
+const LABEL_SHADOW = "rgba(0, 0, 0, 0.75)";
+/** How often to place a cell label based on pixels-per-tile. */
+function labelStride(pixelsPerTile) {
+	if (pixelsPerTile < 12) return 4;
+	if (pixelsPerTile < 24) return 2;
+	return 1;
+}
+/**
+* Draw map-space tile grid lines and coordinate labels over a rendered preview.
+* Canvas (0,0) corresponds to `tileFrame.minX/minY`.
+*/
+function drawCoordinateOverlay(ctx, tileFrame, pixelsPerTile, width, height, outputTileFrame = tileFrame) {
+	const { minX, minY, maxX, maxY } = tileFrame;
+	const cols = maxX - minX;
+	const rows = maxY - minY;
+	if (cols <= 0 || rows <= 0 || pixelsPerTile <= 0) return;
+	ctx.save();
+	ctx.strokeStyle = GRID_STROKE;
+	ctx.lineWidth = 1;
+	ctx.beginPath();
+	for (let i = 0; i <= cols; i++) {
+		const x = i * pixelsPerTile + .5;
+		ctx.moveTo(x, 0);
+		ctx.lineTo(x, height);
+	}
+	for (let j = 0; j <= rows; j++) {
+		const y = j * pixelsPerTile + .5;
+		ctx.moveTo(0, y);
+		ctx.lineTo(width, y);
+	}
+	ctx.stroke();
+	const stride = labelStride(pixelsPerTile);
+	ctx.font = `${Math.max(8, Math.min(12, Math.floor(pixelsPerTile * .35)))}px ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace`;
+	ctx.textBaseline = "top";
+	ctx.textAlign = "left";
+	const pad = Math.max(1, Math.floor(pixelsPerTile * .06));
+	const columnStart = ((outputTileFrame.minX - minX) % stride + stride) % stride;
+	const rowStart = ((outputTileFrame.minY - minY) % stride + stride) % stride;
+	for (let j = rowStart; j < rows; j += stride) for (let i = columnStart; i < cols; i += stride) {
+		const label = `${minX + i},${minY + j}`;
+		const x = i * pixelsPerTile + pad;
+		const y = j * pixelsPerTile + pad;
+		ctx.fillStyle = LABEL_SHADOW;
+		ctx.fillText(label, x + 1, y + 1);
+		ctx.fillStyle = LABEL_FILL;
+		ctx.fillText(label, x, y);
+	}
+	ctx.restore();
+}
+//#endregion
+//#region src/space-background.ts
+const SPACE_FILL = "#000000";
+const DEFAULT_STAR_SEED = 1374772855;
+/** Incommensurate grids overlap into a starfield without a visible repeated lattice. */
+const STAR_LAYERS = [
+	{
+		cellSize: 17,
+		occupancy: .06,
+		brightness: [.24, .5],
+		largeChance: 0,
+		salt: 11
+	},
+	{
+		cellSize: 37,
+		occupancy: .13,
+		brightness: [.42, .76],
+		largeChance: .04,
+		salt: 29
+	},
+	{
+		cellSize: 79,
+		occupancy: .28,
+		brightness: [.68, 1],
+		largeChance: .36,
+		salt: 47
+	}
+];
+/**
+* Factorio `platform_backdrop` placement for Nauvis, expressed relative to
+* screen center with radius 600 on a ~1920×1080 reference viewport:
+* `position = {-680, 601}`, `radius = 600`.
+*/
+const PLANET_OFFSET_X_OVER_RADIUS = -680 / 600;
+const PLANET_OFFSET_Y_OVER_RADIUS = 601 / 600;
+/** Planet radius as a fraction of the shorter canvas edge. */
+const PLANET_RADIUS_FRACTION = .5;
+/** Floor so tiny previews still get a readable bottom-left peek. */
+const PLANET_MIN_RADIUS_PX = 140;
+function packedWidth$2(frame) {
+	return frame.pw ?? frame.w;
+}
+function packedHeight$2(frame) {
+	return frame.ph ?? frame.h;
+}
+/** Deterministic 0..1 hash from integer cell coordinates. */
+const cellHash = (cellX, cellY, salt) => {
+	let h = Math.imul(cellX, 374761393) ^ Math.imul(cellY, 668265263) ^ Math.imul(salt, 1442695041);
+	h = Math.imul(h ^ h >>> 13, 1274126177);
+	return ((h ^ h >>> 16) >>> 0) / 4294967296;
+};
+/**
+* Draw the space-platform planet peeking from the bottom-left, matching
+* Factorio's backdrop offset ratios scaled to the canvas.
+*/
+function drawSpacePlanet(ctx, width, height, planet, viewport) {
+	if (width <= 0 || height <= 0) return;
+	const { frame, image } = planet;
+	if (frame.sw <= 0 || frame.sh <= 0 || frame.w <= 0 || frame.h <= 0) return;
+	const fullWidth = viewport?.fullWidth ?? width;
+	const fullHeight = viewport?.fullHeight ?? height;
+	const radius = Math.max(PLANET_MIN_RADIUS_PX, PLANET_RADIUS_FRACTION * Math.min(fullWidth, fullHeight));
+	const cx = fullWidth / 2 + PLANET_OFFSET_X_OVER_RADIUS * radius - (viewport?.x ?? 0);
+	const cy = fullHeight / 2 + PLANET_OFFSET_Y_OVER_RADIUS * radius - (viewport?.y ?? 0);
+	const scale = radius * 2 / Math.max(frame.sw, frame.sh);
+	const previousSmoothing = ctx.imageSmoothingEnabled;
+	ctx.imageSmoothingEnabled = true;
+	ctx.drawImage(image, frame.x, frame.y, packedWidth$2(frame), packedHeight$2(frame), cx - radius + frame.ox * scale, cy - radius + frame.oy * scale, frame.w * scale, frame.h * scale);
+	ctx.imageSmoothingEnabled = previousSmoothing;
+}
+function smoothstep(value) {
+	return value * value * (3 - 2 * value);
+}
+function lerp(from, to, amount) {
+	return from + (to - from) * amount;
+}
+/** Smooth low-frequency value noise used only to vary local star density. */
+function densityNoise(x, y, seed) {
+	const cellX = Math.floor(x);
+	const cellY = Math.floor(y);
+	const tx = smoothstep(x - cellX);
+	const ty = smoothstep(y - cellY);
+	return lerp(lerp(cellHash(cellX, cellY, seed), cellHash(cellX + 1, cellY, seed), tx), lerp(cellHash(cellX, cellY + 1, seed), cellHash(cellX + 1, cellY + 1, seed), tx), ty);
+}
+function starDensity(x, y, seed) {
+	const broad = densityNoise(x / 310, y / 310, seed ^ 1831565813);
+	const detail = densityNoise(x / 137, y / 137, seed ^ 461845907);
+	return .36 + (broad * .68 + detail * .32) * .88;
+}
+function drawStar(ctx, width, height, x, y, size, color, sparkle) {
+	const left = Math.max(0, x);
+	const top = Math.max(0, y);
+	const clippedWidth = Math.min(width, x + size) - left;
+	const clippedHeight = Math.min(height, y + size) - top;
+	if (clippedWidth <= 0 || clippedHeight <= 0) return;
+	ctx.fillStyle = color;
+	ctx.fillRect(left, top, clippedWidth, clippedHeight);
+	if (!sparkle) return;
+	ctx.fillRect(x - 1, y, 4, 1);
+	ctx.fillRect(x, y - 1, 1, 4);
+}
+/** Fill `width`×`height` with a layered deterministic starfield. */
+function drawSpaceBackground(ctx, width, height, options) {
+	if (width <= 0 || height <= 0) return;
+	ctx.fillStyle = SPACE_FILL;
+	ctx.fillRect(0, 0, width, height);
+	const seed = options?.seed == null ? DEFAULT_STAR_SEED : options.seed >>> 0;
+	const viewportX = options?.viewport?.x ?? 0;
+	const viewportY = options?.viewport?.y ?? 0;
+	for (const layer of STAR_LAYERS) {
+		const firstCellX = Math.max(0, Math.floor(viewportX / layer.cellSize) - 1);
+		const firstCellY = Math.max(0, Math.floor(viewportY / layer.cellSize) - 1);
+		const lastCellX = Math.ceil((viewportX + width) / layer.cellSize);
+		const lastCellY = Math.ceil((viewportY + height) / layer.cellSize);
+		const layerSeed = seed ^ Math.imul(layer.salt, 2654435761);
+		for (let cellY = firstCellY; cellY < lastCellY; cellY++) for (let cellX = firstCellX; cellX < lastCellX; cellX++) {
+			const xUnit = cellHash(cellX, cellY, layerSeed ^ 2);
+			const yUnit = cellHash(cellX, cellY, layerSeed ^ 3);
+			const globalX = cellX * layer.cellSize + Math.floor(xUnit * layer.cellSize);
+			const globalY = cellY * layer.cellSize + Math.floor(yUnit * layer.cellSize);
+			const density = starDensity(globalX, globalY, seed);
+			if (cellHash(cellX, cellY, layerSeed ^ 1) > layer.occupancy * density) continue;
+			const brightness = lerp(layer.brightness[0], layer.brightness[1], cellHash(cellX, cellY, layerSeed ^ 4));
+			const warmth = cellHash(cellX, cellY, layerSeed ^ 5) - .5;
+			const red = Math.round(Math.min(1, brightness * (1 + warmth * .12)) * 255);
+			const green = Math.round(brightness * (1 - Math.abs(warmth) * .035) * 255);
+			const blue = Math.round(Math.min(1, brightness * (1 - warmth * .16)) * 255);
+			const size = cellHash(cellX, cellY, layerSeed ^ 6) < layer.largeChance ? 2 : 1;
+			const sparkle = size === 2 && cellHash(cellX, cellY, layerSeed ^ 7) > .86;
+			drawStar(ctx, width, height, globalX - viewportX, globalY - viewportY, size, `rgb(${red},${green},${blue})`, sparkle);
+		}
+	}
+	if (options?.planet) drawSpacePlanet(ctx, width, height, options.planet, options.viewport);
+}
+//#endregion
+//#region src/terrain-background.ts
+const UINT32_RANGE = 4294967296;
+const VARIANT_SALT = 2654435769;
+const PATCH_SIZE_SALT = 2246822507;
+/** Keep enough smaller patches in uniform terrain to break up large repeated motifs. */
+const MAX_LARGEST_PATCH_PROBABILITY = .4;
+const MAX_INTERMEDIATE_PATCH_PROBABILITY = .7;
+function packedWidth$1(frame) {
+	return frame.pw ?? frame.w;
+}
+function packedHeight$1(frame) {
+	return frame.ph ?? frame.h;
+}
+/** Stable unsigned hash for an absolute terrain-patch cell and background salt. */
+function terrainCellHash(cellX, cellY, salt) {
+	let hash = Math.imul(cellX | 0, 374761393) ^ Math.imul(cellY | 0, 668265263) ^ Math.imul(salt | 0, 1597334677) | 0;
+	hash = Math.imul(hash ^ hash >>> 13, 1274126177);
+	return (hash ^ hash >>> 16) >>> 0;
+}
+/** Derive a fallback salt for pre-seed render databases without coupling terrain types. */
+function terrainSeed(background) {
+	if (Number.isFinite(background.seed)) return (background.seed ?? 0) >>> 0;
+	let seed = 2166136261;
+	for (const patch of [background, ...background.patches ?? []]) {
+		seed = Math.imul(seed ^ Math.floor(patch.patchSize), 16777619) >>> 0;
+		for (const frame of patch.frames) seed = Math.imul(seed ^ frame + 1 >>> 0, 16777619) >>> 0;
+	}
+	return seed >>> 0;
+}
+function greatestCommonDivisor(a, b) {
+	let left = Math.abs(a);
+	let right = Math.abs(b);
+	while (right !== 0) {
+		const remainder = left % right;
+		left = right;
+		right = remainder;
+	}
+	return left;
+}
+/**
+* Split four-or-more variants into two seed-permuted pools on a checkerboard.
+* Direct neighbours cannot select the exact same authored frame, while selection
+* within each pool remains hashed and weighted.
+*/
+function variantCandidates(count, cellX, cellY, seed) {
+	if (count < 4) return Array.from({ length: count }, (_, index) => index);
+	let stride = (seed >>> 8) % count | 1;
+	while (greatestCommonDivisor(stride, count) !== 1) stride += 2;
+	const offset = (seed >>> 16) % count;
+	const parity = cellX + cellY & 1;
+	const candidates = [];
+	for (let logical = parity; logical < count; logical += 2) candidates.push((logical * stride + offset) % count);
+	return candidates;
+}
+function selectVariant(cellX, cellY, patch, seed) {
+	const candidates = variantCandidates(patch.frames.length, cellX, cellY, seed);
+	const unit = terrainCellHash(cellX, cellY, seed ^ VARIANT_SALT) / UINT32_RANGE;
+	const { weights } = patch;
+	if (!weights || weights.length !== patch.frames.length) return candidates[Math.min(candidates.length - 1, Math.floor(unit * candidates.length))] ?? 0;
+	let total = 0;
+	for (const index of candidates) {
+		const weight = weights[index] ?? 0;
+		if (Number.isFinite(weight) && weight > 0) total += weight;
+	}
+	if (total <= 0) return candidates[Math.min(candidates.length - 1, Math.floor(unit * candidates.length))] ?? 0;
+	let target = unit * total;
+	for (const index of candidates) {
+		const weight = weights[index] ?? 0;
+		if (Number.isFinite(weight) && weight > 0) {
+			target -= weight;
+			if (target < 0) return index;
+		}
+	}
+	return candidates[candidates.length - 1] ?? 0;
+}
+function terrainPatchSets(background) {
+	const unique = /* @__PURE__ */ new Map();
+	for (const patch of [background, ...background.patches ?? []]) {
+		const patchSize = Math.floor(patch.patchSize);
+		if (patchSize > 0 && patch.frames.length > 0 && !unique.has(patchSize)) unique.set(patchSize, {
+			patchSize,
+			frames: patch.frames,
+			...patch.weights ? { weights: patch.weights } : {},
+			...patch.probability != null ? { probability: patch.probability } : {}
+		});
+	}
+	return [...unique.values()].sort((left, right) => right.patchSize - left.patchSize);
+}
+function patchProbability(patch, index, count) {
+	if (index === count - 1) return 1;
+	const authored = Number.isFinite(patch.probability) ? Math.max(0, Math.min(1, patch.probability ?? 1)) : 1;
+	return Math.min(authored, index === 0 ? MAX_LARGEST_PATCH_PROBABILITY : MAX_INTERMEDIATE_PATCH_PROBABILITY);
+}
+function rgba$1(color) {
+	const [r, g, b, a] = color;
+	return `rgba(${Math.round(r * 255)},${Math.round(g * 255)},${Math.round(b * 255)},${a})`;
+}
+/**
+* Paint an infinite terrain plane anchored to absolute map coordinates.
+* Only complete, untransformed Factorio patches are drawn. Larger regions may
+* be subdivided into complete smaller authored patches, so every destination is
+* covered exactly once and every texture edge keeps its intended orientation.
+*/
+function drawTerrainBackground(ctx, width, height, options) {
+	if (width <= 0 || height <= 0) return;
+	const { background, fallbackColor, frames, images, pixelsPerTile, tileFrame } = options;
+	ctx.fillStyle = rgba$1(background?.color ?? fallbackColor);
+	ctx.fillRect(0, 0, width, height);
+	if (!background) return;
+	const patchSets = terrainPatchSets(background);
+	const largestPatch = patchSets[0];
+	if (!largestPatch) return;
+	const seed = terrainSeed(background);
+	const previousSmoothing = ctx.imageSmoothingEnabled;
+	ctx.imageSmoothingEnabled = false;
+	const drawPatch = (worldX, worldY, patch) => {
+		const variantIndex = selectVariant(Math.floor(worldX / patch.patchSize), Math.floor(worldY / patch.patchSize), patch, seed ^ Math.imul(patch.patchSize, PATCH_SIZE_SALT));
+		const frameId = patch.frames[variantIndex];
+		const frame = frameId == null ? void 0 : frames[frameId];
+		const image = frame ? images[frame.a] : void 0;
+		if (!frame || !image || frame.sw <= 0 || frame.sh <= 0) return;
+		const patchLeft = Math.round((worldX - tileFrame.minX) * pixelsPerTile);
+		const patchTop = Math.round((worldY - tileFrame.minY) * pixelsPerTile);
+		const patchRight = Math.round((worldX + patch.patchSize - tileFrame.minX) * pixelsPerTile);
+		const patchBottom = Math.round((worldY + patch.patchSize - tileFrame.minY) * pixelsPerTile);
+		const scaleX = (patchRight - patchLeft) / frame.sw;
+		const scaleY = (patchBottom - patchTop) / frame.sh;
+		ctx.drawImage(image, frame.x, frame.y, packedWidth$1(frame), packedHeight$1(frame), patchLeft + frame.ox * scaleX, patchTop + frame.oy * scaleY, frame.w * scaleX, frame.h * scaleY);
+	};
+	const drawRegion = (worldX, worldY, regionSize, patchIndex) => {
+		const patch = patchSets[patchIndex];
+		if (!patch) return;
+		if (patch.patchSize < regionSize) {
+			const step = patch.patchSize;
+			for (let offsetY = 0; offsetY < regionSize; offsetY += step) for (let offsetX = 0; offsetX < regionSize; offsetX += step) drawRegion(worldX + offsetX, worldY + offsetY, step, patchIndex);
+			return;
+		}
+		const cellX = Math.floor(worldX / regionSize);
+		const cellY = Math.floor(worldY / regionSize);
+		const probability = patchProbability(patch, patchIndex, patchSets.length);
+		const usePatch = probability >= 1 || terrainCellHash(cellX, cellY, seed ^ Math.imul(regionSize, PATCH_SIZE_SALT)) / UINT32_RANGE < probability;
+		const nextPatch = patchSets[patchIndex + 1];
+		if (usePatch || !nextPatch || regionSize % nextPatch.patchSize !== 0) {
+			drawPatch(worldX, worldY, patch);
+			return;
+		}
+		const step = nextPatch.patchSize;
+		for (let offsetY = 0; offsetY < regionSize; offsetY += step) for (let offsetX = 0; offsetX < regionSize; offsetX += step) drawRegion(worldX + offsetX, worldY + offsetY, step, patchIndex + 1);
+	};
+	const patchSize = largestPatch.patchSize;
+	const firstCellX = Math.floor(tileFrame.minX / patchSize);
+	const firstCellY = Math.floor(tileFrame.minY / patchSize);
+	const lastCellX = Math.ceil(tileFrame.maxX / patchSize);
+	const lastCellY = Math.ceil(tileFrame.maxY / patchSize);
+	for (let cellY = firstCellY; cellY < lastCellY; cellY++) for (let cellX = firstCellX; cellX < lastCellX; cellX++) drawRegion(cellX * patchSize, cellY * patchSize, patchSize, 0);
+	ctx.imageSmoothingEnabled = previousSmoothing;
+}
+//#endregion
+//#region src/canvas2d/util.ts
+function packedWidth(frame) {
+	return frame.pw ?? frame.w;
+}
+function packedHeight(frame) {
+	return frame.ph ?? frame.h;
+}
+function rgba([r, g, b, a]) {
+	return `rgba(${r * 255}, ${g * 255}, ${b * 255}, ${a})`;
+}
+//#endregion
+//#region src/canvas2d/draw-icon.ts
+const ENTITY_INFO_BASE_ICON_PX = 32;
+/** Scale the foreground icon inside the pin so it sits above the chevron. */
+const REQUEST_PIN_ICON_SCALE = .7;
+/** Shift the pin icon upward (fraction of command size) into the pin body. */
+const REQUEST_PIN_ICON_Y_SHIFT = .1;
+/**
+* Trimmed atlas width still includes soft alpha fringe. Opaque chrome (a>20) is
+* ~44 px of the 48 px trim — scale to that so layout gaps match the visible edge.
+*/
+const REQUEST_PIN_OPAQUE_WIDTH_RATIO = 44 / 48;
+function drawIcon(ctx, cmd, frame, image, frames, images, iconImage, silhouetteImage, ox, oy, ppt) {
+	const size = cmd.size * ppt;
+	const cx = (cmd.x + ox) * ppt;
+	const cy = (cmd.y + oy) * ppt;
+	const isRequestPin = cmd.backingStyle === "request-pin";
+	const left = cx - size / 2;
+	const top = cy - size / 2;
+	const backingFrame = cmd.backingFrame == null ? void 0 : frames[cmd.backingFrame];
+	const backingImage = backingFrame ? images[backingFrame.a] : void 0;
+	if (backingFrame && backingImage) {
+		const backingScale = size / (isRequestPin ? Math.max(1, backingFrame.w * REQUEST_PIN_OPAQUE_WIDTH_RATIO) : ENTITY_INFO_BASE_ICON_PX);
+		const backingWidth = backingFrame.sw * backingScale;
+		const backingHeight = backingFrame.sh * backingScale;
+		const backingLeft = cx - backingWidth / 2;
+		const backingTop = cy - backingHeight / 2;
+		const previousAlpha = ctx.globalAlpha;
+		if (!isRequestPin) ctx.globalAlpha = previousAlpha * .16;
+		ctx.drawImage(backingImage, backingFrame.x, backingFrame.y, packedWidth(backingFrame), packedHeight(backingFrame), backingLeft + backingFrame.ox * backingScale, backingTop + backingFrame.oy * backingScale, backingFrame.w * backingScale, backingFrame.h * backingScale);
+		ctx.globalAlpha = previousAlpha;
+	} else if (cmd.backing) {
+		ctx.fillStyle = "rgba(0,0,0,0.6)";
+		const radius = size * .15;
+		if (typeof ctx.roundRect === "function") {
+			ctx.beginPath();
+			ctx.roundRect(left, top, size, size, radius);
+			ctx.fill();
+		} else ctx.fillRect(left, top, size, size);
+	}
+	const drawSize = isRequestPin ? size * REQUEST_PIN_ICON_SCALE : size;
+	const drawCx = cx;
+	const drawCy = isRequestPin ? cy - size * REQUEST_PIN_ICON_Y_SHIFT : cy;
+	const drawLeft = drawCx - drawSize / 2;
+	const drawTop = drawCy - drawSize / 2;
+	const iconScaleX = frame.sw === 0 ? 0 : drawSize / frame.sw;
+	const iconScaleY = frame.sh === 0 ? 0 : drawSize / frame.sh;
+	const iconLeft = drawLeft + frame.ox * iconScaleX;
+	const iconTop = drawTop + frame.oy * iconScaleY;
+	const iconWidth = frame.w * iconScaleX;
+	const iconHeight = frame.h * iconScaleY;
+	const hasEntityInfoBacking = !isRequestPin && (backingFrame != null || cmd.backing === true);
+	const needsEntityInfoSilhouette = !isRequestPin && (hasEntityInfoBacking || cmd.silhouette === true);
+	const drawIconLayer = (sourceImage, sourceX, sourceY, sourceW, sourceH, destLeft, destTop, destWidth, destHeight) => {
+		if (cmd.rotation != null && cmd.rotation !== 0) {
+			ctx.save();
+			ctx.translate(drawCx, drawCy);
+			ctx.rotate(cmd.rotation * Math.PI / 180);
+			ctx.drawImage(sourceImage, sourceX, sourceY, sourceW, sourceH, destLeft - drawCx, destTop - drawCy, destWidth, destHeight);
+			ctx.restore();
+			return;
+		}
+		ctx.drawImage(sourceImage, sourceX, sourceY, sourceW, sourceH, destLeft, destTop, destWidth, destHeight);
+	};
+	if (needsEntityInfoSilhouette && iconImage && silhouetteImage) {
+		const pad = entityInfoSilhouettePadPx();
+		const sourcePad = Math.max(1, Math.round(pad * (packedWidth(frame) / frame.w)));
+		const padX = pad * iconScaleX;
+		const padY = pad * iconScaleY;
+		drawIconLayer(silhouetteImage, 0, 0, packedWidth(frame) + 2 * sourcePad, packedHeight(frame) + 2 * sourcePad, iconLeft - padX, iconTop - padY, iconWidth + 2 * padX, iconHeight + 2 * padY);
+		drawIconLayer(iconImage, 0, 0, packedWidth(frame), packedHeight(frame), iconLeft, iconTop, iconWidth, iconHeight);
+		return;
+	}
+	drawIconLayer(iconImage ?? image, iconImage ? 0 : frame.x, iconImage ? 0 : frame.y, packedWidth(frame), packedHeight(frame), iconLeft, iconTop, iconWidth, iconHeight);
+}
+//#endregion
+//#region src/canvas2d/draw-snap-grid.ts
+/** Factorio snap-rectangle green. */
+const SNAP_GRID_STROKE = "#3cff00";
+const SNAP_GRID_STROKE_OUTER = "#0a3d00";
+/** Dash pattern in tiles at 32 ppt. */
+const SNAP_DASH_AT_32PPT = [10, 6];
+/**
+* Draw the blueprint snap-to-grid rectangle as a dashed perimeter along the
+* four edges (no corner L-brackets).
+*/
+function drawSnapGrid(ctx, cmd, ox, oy, ppt) {
+	const { x, y, w, h } = cmd;
+	if (!(w > 0) || !(h > 0)) return;
+	drawSnapGridStroke(ctx, x, y, w, h, ox, oy, ppt);
+}
+function drawSnapGridStroke(ctx, x, y, w, h, ox, oy, ppt) {
+	const px = (x + ox) * ppt;
+	const py = (y + oy) * ppt;
+	const pw = w * ppt;
+	const ph = h * ppt;
+	const lineWidth = Math.max(2, 3 * ppt / 32);
+	const dash = SNAP_DASH_AT_32PPT.map((v) => v * ppt / 32);
+	ctx.save();
+	if (typeof ctx.setLineDash === "function") ctx.setLineDash(dash);
+	ctx.lineCap = "butt";
+	ctx.lineWidth = lineWidth + 2;
+	ctx.strokeStyle = SNAP_GRID_STROKE_OUTER;
+	strokeRectCompat(ctx, px + .5, py + .5, pw - 1, ph - 1);
+	ctx.lineWidth = lineWidth;
+	ctx.strokeStyle = SNAP_GRID_STROKE;
+	strokeRectCompat(ctx, px + .5, py + .5, pw - 1, ph - 1);
+	if (typeof ctx.setLineDash === "function") ctx.setLineDash([]);
+	ctx.restore();
+}
+function strokeRectCompat(ctx, x, y, w, h) {
+	if (typeof ctx.strokeRect === "function") {
+		ctx.strokeRect(x, y, w, h);
+		return;
+	}
+	ctx.beginPath();
+	ctx.rect(x, y, w, h);
+	ctx.stroke();
+}
+//#endregion
+//#region src/canvas2d/draw-sprite.ts
+const PIXEL_SNAPPED_RAIL_LAYERS = /* @__PURE__ */ new Set([
+	RENDER_LAYERS["rail-stone-path-lower"],
+	RENDER_LAYERS["rail-stone-path"],
+	RENDER_LAYERS["rail-tie"],
+	RENDER_LAYERS["rail-screw"],
+	RENDER_LAYERS["rail-metal"],
+	RENDER_LAYERS["elevated-rail-stone-path-lower"],
+	RENDER_LAYERS["elevated-rail-stone-path"],
+	RENDER_LAYERS["elevated-rail-tie"],
+	RENDER_LAYERS["elevated-rail-screw"],
+	RENDER_LAYERS["elevated-rail-metal"]
+]);
+function drawRect(ctx, cmd, ox, oy, ppt) {
+	ctx.fillStyle = rgba(cmd.color);
+	ctx.fillRect((cmd.x + ox) * ppt, (cmd.y + oy) * ppt, cmd.w * ppt, cmd.h * ppt);
+}
+function atlasSourceRect(frame, src) {
+	const packedW = packedWidth(frame);
+	const packedH = packedHeight(frame);
+	const atlasScaleX = frame.w === 0 ? 0 : packedW / frame.w;
+	const atlasScaleY = frame.h === 0 ? 0 : packedH / frame.h;
+	const relX = src.x - frame.ox;
+	const relY = src.y - frame.oy;
+	return {
+		x: frame.x + relX * atlasScaleX,
+		y: frame.y + relY * atlasScaleY,
+		w: src.w * atlasScaleX,
+		h: src.h * atlasScaleY
+	};
+}
+function drawSprite(ctx, cmd, frame, image, ox, oy, ppt, createCanvas) {
+	let dx = (cmd.x + ox) * ppt;
+	let dy = (cmd.y + oy) * ppt;
+	let dw = cmd.w * ppt;
+	let dh = cmd.h * ppt;
+	if (PIXEL_SNAPPED_RAIL_LAYERS.has(cmd.layer) && (cmd.rotation ?? 0) === 0) {
+		const right = Math.round((cmd.x + cmd.w + ox) * ppt);
+		const bottom = Math.round((cmd.y + cmd.h + oy) * ppt);
+		dx = Math.round(dx);
+		dy = Math.round(dy);
+		dw = right - dx;
+		dh = bottom - dy;
+	}
+	const src = cmd.src ?? {
+		x: 0,
+		y: 0,
+		w: frame.sw,
+		h: frame.sh
+	};
+	const scaleX = src.w === 0 ? 0 : dw / src.w;
+	const scaleY = src.h === 0 ? 0 : dh / src.h;
+	const atlasSrc = cmd.src ? atlasSourceRect(frame, src) : {
+		x: frame.x,
+		y: frame.y,
+		w: packedWidth(frame),
+		h: packedHeight(frame)
+	};
+	const trimmedDx = cmd.src ? dx : dx + frame.ox * scaleX;
+	const trimmedDy = cmd.src ? dy : dy + frame.oy * scaleY;
+	const trimmedDw = cmd.src ? dw : frame.w * scaleX;
+	const trimmedDh = cmd.src ? dh : frame.h * scaleY;
+	const prevAlpha = ctx.globalAlpha;
+	if (cmd.shadow) ctx.globalAlpha = prevAlpha * .5;
+	const flipX = cmd.flipX === true;
+	const flipY = cmd.flipY === true;
+	const rotation = cmd.rotation ?? 0;
+	const hasClip = cmd.clip != null;
+	const tint = cmd.tint;
+	const blit = (target, destDx, destDy, destDw, destDh) => {
+		target.drawImage(image, atlasSrc.x, atlasSrc.y, atlasSrc.w, atlasSrc.h, destDx, destDy, destDw, destDh);
+	};
+	/** Multiply-tint the sprite via an offscreen canvas, then draw the result. */
+	const tintedSource = () => {
+		if (!tint || !createCanvas) return null;
+		const tw = Math.max(1, Math.ceil(trimmedDw));
+		const th = Math.max(1, Math.ceil(trimmedDh));
+		const scratch = createCanvas(tw, th);
+		scratch.width = tw;
+		scratch.height = th;
+		const sctx = scratch.getContext("2d");
+		if (!sctx) return null;
+		sctx.imageSmoothingEnabled = false;
+		blit(sctx, 0, 0, tw, th);
+		sctx.globalCompositeOperation = "multiply";
+		sctx.fillStyle = rgba(tint);
+		sctx.fillRect(0, 0, tw, th);
+		sctx.globalCompositeOperation = "destination-in";
+		blit(sctx, 0, 0, tw, th);
+		sctx.globalCompositeOperation = "source-over";
+		return {
+			image: scratch,
+			w: tw,
+			h: th
+		};
+	};
+	const tinted = tintedSource();
+	if (hasClip) {
+		ctx.save();
+		ctx.beginPath();
+		ctx.rect((cmd.clip.x + ox) * ppt, (cmd.clip.y + oy) * ppt, cmd.clip.w * ppt, cmd.clip.h * ppt);
+		ctx.clip();
+	}
+	if (flipX || flipY || rotation !== 0) {
+		const ucx = dx + dw / 2;
+		const ucy = dy + dh / 2;
+		ctx.save();
+		ctx.translate(ucx, ucy);
+		if (rotation !== 0) ctx.rotate(rotation * Math.PI / 180);
+		ctx.scale(flipX ? -1 : 1, flipY ? -1 : 1);
+		if (tinted) ctx.drawImage(tinted.image, 0, 0, tinted.w, tinted.h, trimmedDx - ucx, trimmedDy - ucy, trimmedDw, trimmedDh);
+		else blit(ctx, trimmedDx - ucx, trimmedDy - ucy, trimmedDw, trimmedDh);
+		ctx.restore();
+	} else if (tinted) ctx.drawImage(tinted.image, 0, 0, tinted.w, tinted.h, trimmedDx, trimmedDy, trimmedDw, trimmedDh);
+	else blit(ctx, trimmedDx, trimmedDy, trimmedDw, trimmedDh);
+	const seamBleed = cmd.seamBleed;
+	if (seamBleed && !hasClip && !tinted && !flipX && !flipY && rotation === 0) {
+		const bleed = (clipX, clipY, clipW, clipH, sx, sy) => {
+			ctx.save();
+			ctx.beginPath();
+			ctx.rect(clipX, clipY, clipW, clipH);
+			ctx.clip();
+			blit(ctx, trimmedDx + sx, trimmedDy + sy, trimmedDw, trimmedDh);
+			ctx.restore();
+		};
+		const seamBand = 2;
+		if (seamBleed.top) bleed(dx, dy - seamBand, dw, seamBand, 0, -2);
+		if (seamBleed.right) bleed(dx + dw, dy, seamBand, dh, seamBand, 0);
+		if (seamBleed.bottom) bleed(dx, dy + dh, dw, seamBand, 0, seamBand);
+		if (seamBleed.left) bleed(dx - seamBand, dy, seamBand, dh, -2, 0);
+	}
+	if (hasClip) ctx.restore();
+	if (cmd.shadow) ctx.globalAlpha = prevAlpha;
+}
+function shadowSpriteBounds(cmd, frame, ox, oy, ppt, outputWidth, outputHeight) {
+	const dx = (cmd.x + ox) * ppt;
+	const dy = (cmd.y + oy) * ppt;
+	const dw = cmd.w * ppt;
+	const dh = cmd.h * ppt;
+	const scaleX = frame.sw === 0 ? 0 : dw / frame.sw;
+	const scaleY = frame.sh === 0 ? 0 : dh / frame.sh;
+	const left = dx + frame.ox * scaleX;
+	const top = dy + frame.oy * scaleY;
+	const right = left + frame.w * scaleX;
+	const bottom = top + frame.h * scaleY;
+	const centerX = dx + dw / 2;
+	const centerY = dy + dh / 2;
+	const radians = (cmd.rotation ?? 0) * Math.PI / 180;
+	const cos = Math.cos(radians);
+	const sin = Math.sin(radians);
+	const flipX = cmd.flipX === true ? -1 : 1;
+	const flipY = cmd.flipY === true ? -1 : 1;
+	let minX = Number.POSITIVE_INFINITY;
+	let minY = Number.POSITIVE_INFINITY;
+	let maxX = Number.NEGATIVE_INFINITY;
+	let maxY = Number.NEGATIVE_INFINITY;
+	for (const [x, y] of [
+		[left, top],
+		[right, top],
+		[right, bottom],
+		[left, bottom]
+	]) {
+		const localX = (x - centerX) * flipX;
+		const localY = (y - centerY) * flipY;
+		const transformedX = centerX + localX * cos - localY * sin;
+		const transformedY = centerY + localX * sin + localY * cos;
+		minX = Math.min(minX, transformedX);
+		minY = Math.min(minY, transformedY);
+		maxX = Math.max(maxX, transformedX);
+		maxY = Math.max(maxY, transformedY);
+	}
+	minX = Math.floor(minX) - 1;
+	minY = Math.floor(minY) - 1;
+	maxX = Math.ceil(maxX) + 1;
+	maxY = Math.ceil(maxY) + 1;
+	if (cmd.clip) {
+		const clipLeft = (cmd.clip.x + ox) * ppt;
+		const clipTop = (cmd.clip.y + oy) * ppt;
+		const clipRight = clipLeft + cmd.clip.w * ppt;
+		const clipBottom = clipTop + cmd.clip.h * ppt;
+		minX = Math.max(minX, clipLeft);
+		minY = Math.max(minY, clipTop);
+		maxX = Math.min(maxX, clipRight);
+		maxY = Math.min(maxY, clipBottom);
+	}
+	minX = Math.max(0, minX);
+	minY = Math.max(0, minY);
+	maxX = Math.min(outputWidth, maxX);
+	maxY = Math.min(outputHeight, maxY);
+	return maxX > minX && maxY > minY ? {
+		minX,
+		minY,
+		maxX,
+		maxY
+	} : null;
+}
+//#endregion
+//#region src/canvas2d/draw-text.ts
+function drawText(ctx, cmd, ox, oy, ppt) {
+	const sizePx = Math.max(1, cmd.size * ppt);
+	ctx.save();
+	ctx.font = fpsrTextFontCss(sizePx);
+	ctx.textAlign = cmd.align ?? "left";
+	ctx.textBaseline = cmd.baseline ?? "top";
+	ctx.fillStyle = rgba(cmd.color);
+	ctx.fillText(cmd.text, (cmd.x + ox) * ppt, (cmd.y + oy) * ppt);
+	ctx.restore();
+}
+//#endregion
+//#region src/canvas2d/draw-wire.ts
+const WIRE_COLORS = {
+	copper: "#cf7c00",
+	red: "#c83718",
+	green: "#588c38"
+};
+/** Stroke width in px at 32 ppt (FBE uses 1.5; we go slightly thinner). */
+const WIRE_WIDTH_AT_32PPT = 1;
+const WIRE_ALPHA = .72;
+/** Factorio rolling-stock coupling overlay (procedural; no dedicated sprite).
+* In-game measured color `#658024` (olive). Chart constants like
+* `green_wire_color` / `train_preview_path_outline_color` are pure `#00ff00`
+* and do not match this overlay; `vehicle_wagon_connection_color` is map-only red. */
+const TRAIN_CHAIN_COLOR = "#658024";
+/** Stroke width in px at 32 ppt (in-game coupling overlay ≈ 3 px). */
+const TRAIN_CHAIN_WIDTH_AT_32PPT = 3;
+const TRAIN_CHAIN_ALPHA = .95;
+function drawWire(ctx, cmd, ox, oy, ppt) {
+	const x1 = (cmd.x1 + ox) * ppt;
+	const y1 = (cmd.y1 + oy) * ppt;
+	const x2 = (cmd.x2 + ox) * ppt;
+	const y2 = (cmd.y2 + oy) * ppt;
+	const dist = Math.hypot(x2 - x1, y2 - y1);
+	const mx = (x1 + x2) / 2;
+	const my = (y1 + y2) / 2 + .15 * dist;
+	const prevAlpha = ctx.globalAlpha;
+	ctx.beginPath();
+	ctx.strokeStyle = WIRE_COLORS[cmd.wire];
+	ctx.lineWidth = WIRE_WIDTH_AT_32PPT * ppt / 32;
+	ctx.lineCap = "round";
+	ctx.globalAlpha = prevAlpha * WIRE_ALPHA;
+	ctx.moveTo(x1, y1);
+	ctx.quadraticCurveTo(mx, my, x2, y2);
+	ctx.stroke();
+	ctx.globalAlpha = prevAlpha;
+}
+function drawTrainChain(ctx, cmd, ox, oy, ppt) {
+	const prevAlpha = ctx.globalAlpha;
+	ctx.strokeStyle = TRAIN_CHAIN_COLOR;
+	ctx.lineWidth = TRAIN_CHAIN_WIDTH_AT_32PPT * ppt / 32;
+	ctx.lineCap = "round";
+	ctx.globalAlpha = prevAlpha * TRAIN_CHAIN_ALPHA;
+	for (const s of cmd.segments) {
+		ctx.beginPath();
+		ctx.moveTo((s.x1 + ox) * ppt, (s.y1 + oy) * ppt);
+		ctx.lineTo((s.x2 + ox) * ppt, (s.y2 + oy) * ppt);
+		ctx.stroke();
+	}
+	const r = TRAIN_CHAIN_JOINT_RADIUS * ppt;
+	for (const j of cmd.joints) {
+		ctx.beginPath();
+		ctx.arc((j.x + ox) * ppt, (j.y + oy) * ppt, r, 0, Math.PI * 2);
+		ctx.stroke();
+	}
+	ctx.globalAlpha = prevAlpha;
+}
+//#endregion
+//#region src/canvas2d/execute.ts
+const TERRAIN_FALLBACK_COLOR = [
+	141 / 255,
+	104 / 255,
+	60 / 255,
+	1
+];
+/**
+* Execute a sorted draw list against a Canvas2D context.
+* `images[i]` is the atlas image for atlas index i.
+*/
+function executeDrawList(ctx, list, images, opts) {
+	const ppt = opts.pixelsPerTile;
+	const pad = opts.padTiles ?? 0;
+	const { frames } = opts;
+	const { minX, minY, maxX, maxY } = list.bounds;
+	const frame = opts.tileFrame ?? {
+		minX: Math.floor(minX) - pad,
+		minY: Math.floor(minY) - pad,
+		maxX: Math.ceil(maxX) + pad,
+		maxY: Math.ceil(maxY) + pad
+	};
+	const ox = -frame.minX;
+	const oy = -frame.minY;
+	const width = Math.max(0, (frame.maxX - frame.minX) * ppt);
+	const height = Math.max(0, (frame.maxY - frame.minY) * ppt);
+	const shadowTileSize = Math.max(1, Math.floor(opts.shadowTileSize ?? 1024));
+	const stats = opts.stats;
+	if (stats) {
+		stats.shadowRuns = 0;
+		stats.shadowTiles = 0;
+		stats.shadowCompositedPixels = 0;
+		stats.shadowPeakScratchPixels = 0;
+	}
+	ctx.imageSmoothingEnabled = false;
+	if (opts.showSpace) {
+		const planetFrameId = opts.spaceBackground?.planetFrame;
+		const planetFrame = planetFrameId != null ? opts.frames[planetFrameId] : void 0;
+		const planetImage = planetFrame ? images[planetFrame.a] : void 0;
+		drawSpaceBackground(ctx, width, height, {
+			seed: planetFrameId,
+			viewport: opts.outputTileFrame ? {
+				x: (frame.minX - opts.outputTileFrame.minX) * ppt,
+				y: (frame.minY - opts.outputTileFrame.minY) * ppt,
+				fullWidth: (opts.outputTileFrame.maxX - opts.outputTileFrame.minX) * ppt,
+				fullHeight: (opts.outputTileFrame.maxY - opts.outputTileFrame.minY) * ppt
+			} : void 0,
+			planet: planetFrame && planetImage ? {
+				frame: planetFrame,
+				image: planetImage
+			} : void 0
+		});
+	} else if (opts.terrainBackground) drawTerrainBackground(ctx, width, height, {
+		tileFrame: frame,
+		pixelsPerTile: ppt,
+		frames: opts.frames,
+		images,
+		background: opts.terrainBackground,
+		fallbackColor: opts.terrainBackground.color ?? TERRAIN_FALLBACK_COLOR
+	});
+	else if (opts.showCheckerboard) drawTileCheckerboard(ctx, width, height, ppt, frame.minX, frame.minY);
+	else if (opts.background) {
+		ctx.fillStyle = rgba(opts.background);
+		ctx.fillRect(0, 0, width, height);
+	}
+	let shadowCanvas;
+	let shadowCtx = null;
+	const renderShadowRun = (commands) => {
+		if (!opts.createCanvas || commands.length === 0 || width <= 0 || height <= 0) return;
+		const tileWidth = Math.min(shadowTileSize, Math.ceil(width));
+		const tileHeight = Math.min(shadowTileSize, Math.ceil(height));
+		if (!shadowCanvas) {
+			shadowCanvas = opts.createCanvas(tileWidth, tileHeight);
+			shadowCanvas.width = tileWidth;
+			shadowCanvas.height = tileHeight;
+			shadowCtx = shadowCanvas.getContext("2d");
+			if (shadowCtx) shadowCtx.imageSmoothingEnabled = false;
+		}
+		if (!shadowCtx || !shadowCanvas) return;
+		const columns = Math.ceil(width / shadowTileSize);
+		const bins = /* @__PURE__ */ new Map();
+		for (const command of commands) {
+			const spriteFrame = frames[command.frame];
+			const image = spriteFrame ? images[spriteFrame.a] : void 0;
+			if (!spriteFrame || !image) continue;
+			const bounds = shadowSpriteBounds(command, spriteFrame, ox, oy, ppt, width, height);
+			if (!bounds) continue;
+			const minTileX = Math.floor(bounds.minX / shadowTileSize);
+			const minTileY = Math.floor(bounds.minY / shadowTileSize);
+			const maxTileX = Math.floor((bounds.maxX - 1) / shadowTileSize);
+			const maxTileY = Math.floor((bounds.maxY - 1) / shadowTileSize);
+			for (let tileY = minTileY; tileY <= maxTileY; tileY++) for (let tileX = minTileX; tileX <= maxTileX; tileX++) {
+				const key = tileY * columns + tileX;
+				const bin = bins.get(key);
+				if (bin) bin.push(command);
+				else bins.set(key, [command]);
+			}
+		}
+		if (stats) {
+			stats.shadowRuns++;
+			stats.shadowPeakScratchPixels = Math.max(stats.shadowPeakScratchPixels, shadowCanvas.width * shadowCanvas.height);
+		}
+		const prevAlpha = ctx.globalAlpha;
+		for (const [key, tileCommands] of [...bins].sort((a, b) => a[0] - b[0])) {
+			const tileX = key % columns;
+			const tileY = Math.floor(key / columns);
+			const outputX = tileX * shadowTileSize;
+			const outputY = tileY * shadowTileSize;
+			const outputTileWidth = Math.min(shadowTileSize, width - outputX);
+			const outputTileHeight = Math.min(shadowTileSize, height - outputY);
+			shadowCtx.clearRect(0, 0, shadowCanvas.width, shadowCanvas.height);
+			shadowCtx.save();
+			shadowCtx.translate(-outputX, -outputY);
+			for (const command of tileCommands) {
+				const spriteFrame = frames[command.frame];
+				const image = spriteFrame ? images[spriteFrame.a] : void 0;
+				if (!spriteFrame || !image) continue;
+				drawSprite(shadowCtx, {
+					...command,
+					shadow: false
+				}, spriteFrame, image, ox, oy, ppt, opts.createCanvas);
+			}
+			shadowCtx.restore();
+			ctx.globalAlpha = prevAlpha * .5;
+			ctx.drawImage(shadowCanvas, 0, 0, outputTileWidth, outputTileHeight, outputX, outputY, outputTileWidth, outputTileHeight);
+			if (stats) {
+				stats.shadowTiles++;
+				stats.shadowCompositedPixels += outputTileWidth * outputTileHeight;
+			}
+		}
+		ctx.globalAlpha = prevAlpha;
+	};
+	for (let commandIndex = 0; commandIndex < list.commands.length; commandIndex++) {
+		const cmd = list.commands[commandIndex];
+		if (cmd.kind === "sprite" && cmd.shadow && opts.createCanvas) {
+			const shadowRun = [];
+			while (commandIndex < list.commands.length) {
+				const candidate = list.commands[commandIndex];
+				if (candidate?.kind !== "sprite" || !candidate.shadow) break;
+				shadowRun.push(candidate);
+				commandIndex++;
+			}
+			commandIndex--;
+			renderShadowRun(shadowRun);
+			continue;
+		}
+		switch (cmd.kind) {
+			case "rect":
+				drawRect(ctx, cmd, ox, oy, ppt);
+				break;
+			case "sprite": {
+				const frame = frames[cmd.frame];
+				const image = frame ? images[frame.a] : void 0;
+				if (!frame || !image) break;
+				drawSprite(ctx, cmd, frame, image, ox, oy, ppt, opts.createCanvas);
+				break;
+			}
+			case "wire":
+				drawWire(ctx, cmd, ox, oy, ppt);
+				break;
+			case "train-chain":
+				drawTrainChain(ctx, cmd, ox, oy, ppt);
+				break;
+			case "snap-grid":
+				drawSnapGrid(ctx, cmd, ox, oy, ppt);
+				break;
+			case "text":
+				drawText(ctx, cmd, ox, oy, ppt);
+				break;
+			case "icon": {
+				const frame = frames[cmd.frame];
+				const image = frame ? images[frame.a] : void 0;
+				if (!frame || !image) break;
+				drawIcon(ctx, cmd, frame, image, frames, images, opts.iconImages?.get(cmd.frame), opts.silhouetteImages?.get(cmd.frame), ox, oy, ppt);
+				break;
+			}
+		}
+	}
+	if (opts.showCoordinates) drawCoordinateOverlay(ctx, frame, ppt, width, height, opts.outputTileFrame ?? frame);
+}
+//#endregion
+export { drawCoordinateOverlay as a, FPSR_TEXT_FONT_FALLBACK as c, drawSpacePlanet as i, FPSR_TEXT_FONT_FAMILY as l, drawTerrainBackground as n, blitWithTileCheckerboard as o, drawSpaceBackground as r, drawTileCheckerboard as s, executeDrawList as t, fpsrTextFontCss as u };
+
+//# sourceMappingURL=execute-CRZV5zw1.js.map