@fcannizzaro/streamdeck-react 0.1.10 → 0.1.12

package/dist/render/pipeline.js

@@ -1,62 +1,329 @@
-import { vnodeToElement } from "../reconciler/vnode.js";
-import { fnv1a } from "./cache.js";
+import { isContainerDirty } from "../reconciler/vnode.js";
+import { computeCacheKey, computeTreeHash, fnv1a } from "./cache.js";
+import { getBufferPool } from "./buffer-pool.js";
 import { encodePng } from "./png.js";
-import { createElement } from "react";
-import { fromJsx } from "@takumi-rs/helpers/jsx";
+import { getImageCache, getTouchStripCache } from "./image-cache.js";
+import { metrics } from "./metrics.js";
+import { serializeSvgTree } from "./svg.js";
 //#region src/render/pipeline.ts
+var ROOT_STYLE = {
+	display: "flex",
+	width: "100%",
+	height: "100%"
+};
+/** Warn threshold for consecutive identical renders in debug mode. */
+var DUP_RENDER_WARN_THRESHOLD = 3;
+/** Maximum recommended VNode tree depth. Warn in debug mode when exceeded. */
+var MAX_DEPTH_WARN = 25;
+/** Whether we've already warned about tree depth (avoid log spam). */
+var depthWarned = false;
+var SKIP_PROPS = new Set([
+	"children",
+	"className",
+	"src",
+	"tw"
+]);
+function copyPropsToNode(target, props) {
+	for (const key of Object.keys(props)) if (!SKIP_PROPS.has(key)) target[key] = props[key];
+}
+function vnodeToTakumiNode(node, depth = 0) {
+	if (!depthWarned && depth > MAX_DEPTH_WARN) {
+		depthWarned = true;
+		console.warn(`[@fcannizzaro/streamdeck-react] VNode tree depth ${depth} exceeds recommended limit ${MAX_DEPTH_WARN}. Deep nesting increases render cost.`);
+	}
+	if (node.type === "#text") return {
+		type: "text",
+		text: node.text ?? ""
+	};
+	const props = node.props;
+	const rawTw = typeof props.tw === "string" ? props.tw : void 0;
+	const className = props.className;
+	let tw = rawTw;
+	if (typeof className === "string" && className.length > 0) tw = tw ? tw + " " + className : className;
+	if (node.type === "img" && typeof props.src === "string") {
+		const result = {
+			type: "image",
+			src: props.src
+		};
+		if (tw) result.tw = tw;
+		copyPropsToNode(result, props);
+		return result;
+	}
+	if (node.type === "svg") {
+		const result = {
+			type: "image",
+			src: serializeSvgTree(node),
+			tagName: "svg"
+		};
+		const width = typeof props.width === "number" ? props.width : void 0;
+		const height = typeof props.height === "number" ? props.height : void 0;
+		if (width != null) result.width = width;
+		if (height != null) result.height = height;
+		if (tw) result.tw = tw;
+		if (props.style) result.style = props.style;
+		return result;
+	}
+	const result = { type: "container" };
+	if (tw) result.tw = tw;
+	copyPropsToNode(result, props);
+	if (node.children.length > 0) result.children = node.children.map((child) => vnodeToTakumiNode(child, depth + 1));
+	return result;
+}
+/** Build the root Takumi container wrapping the VNode children. */
+function buildTakumiRoot(container) {
+	return {
+		type: "container",
+		style: ROOT_STYLE,
+		children: container.children.map(vnodeToTakumiNode)
+	};
+}
+function measureTree(nodes) {
+	let maxDepth = 0;
+	let count = 0;
+	function walk(children, depth) {
+		for (const child of children) {
+			count++;
+			if (depth > maxDepth) maxDepth = depth;
+			walk(child.children, depth + 1);
+		}
+	}
+	walk(nodes, 1);
+	return {
+		depth: maxDepth,
+		count
+	};
+}
 function bufferToDataUri(buffer, format) {
 	return `data:image/${format};base64,${(Buffer.isBuffer(buffer) ? buffer : Buffer.from(buffer)).toString("base64")}`;
 }
+function emitProfile(config, times, opts) {
+	const stats = measureTree(opts.container.children);
+	const cache = config.imageCacheMaxBytes > 0 ? getImageCache(config.imageCacheMaxBytes) : null;
+	config.onProfile({
+		vnodeConversionMs: times.t1 - times.t0,
+		takumiRenderMs: times.t2 - times.t1,
+		hashMs: times.t3 - times.t2,
+		base64Ms: 0,
+		totalMs: times.t3 - times.t0,
+		skipped: opts.skipped,
+		cacheHit: opts.cacheHit,
+		treeDepth: stats.depth,
+		nodeCount: stats.count,
+		cacheStats: cache?.stats ?? null
+	});
+}
 async function renderToDataUri(container, width, height, config) {
 	if (container.children.length === 0) return null;
-	const { node, stylesheets } = await fromJsx(createElement("div", { style: {
-		display: "flex",
-		width: "100%",
-		height: "100%"
-	} }, ...container.children.map(vnodeToElement)));
-	const buffer = await config.renderer.render(node, {
-		width,
-		height,
-		format: config.imageFormat,
-		stylesheets,
-		devicePixelRatio: config.devicePixelRatio
-	});
+	metrics.recordFlush();
+	if (config.caching && !isContainerDirty(container)) {
+		metrics.recordDirtySkip();
+		return null;
+	}
+	const profiling = config.onProfile != null;
+	const t0 = profiling ? performance.now() : 0;
+	let t1 = t0;
+	let t2 = t0;
+	let treeHash;
+	let cacheKey;
+	if (config.caching && config.imageCacheMaxBytes > 0) {
+		treeHash = computeTreeHash(container);
+		cacheKey = computeCacheKey(treeHash, width, height, config.devicePixelRatio, config.imageFormat);
+		const cached = getImageCache(config.imageCacheMaxBytes).get(cacheKey);
+		if (cached !== void 0) {
+			metrics.recordCacheHit();
+			if (profiling) {
+				const tNow = performance.now();
+				emitProfile(config, {
+					t0,
+					t1: tNow,
+					t2: tNow,
+					t3: tNow
+				}, {
+					skipped: false,
+					cacheHit: true,
+					container
+				});
+			}
+			container._dupCount = 0;
+			config.onRender?.(container, cached);
+			return cached;
+		}
+	}
+	let buffer;
+	if (config.renderPool?.isAvailable) {
+		buffer = await config.renderPool.render(container.children, width, height, config.imageFormat, config.devicePixelRatio);
+		t2 = profiling ? performance.now() : 0;
+		t1 = t0;
+	} else {
+		const rootNode = buildTakumiRoot(container);
+		t1 = profiling ? performance.now() : 0;
+		buffer = await config.renderer.render(rootNode, {
+			width,
+			height,
+			format: config.imageFormat,
+			devicePixelRatio: config.devicePixelRatio
+		});
+		t2 = profiling ? performance.now() : 0;
+	}
 	if (config.caching) {
 		const hash = fnv1a(buffer);
-		if (hash === container.lastSvgHash) return null;
+		if (hash === container.lastSvgHash) {
+			metrics.recordHashDedup();
+			if (config.debug) {
+				container._dupCount++;
+				if (container._dupCount > DUP_RENDER_WARN_THRESHOLD) console.warn(`[@fcannizzaro/streamdeck-react] ${container._dupCount} consecutive identical renders — component likely re-rendering without visual change`);
+			}
+			if (profiling) {
+				const tEnd = performance.now();
+				emitProfile(config, {
+					t0,
+					t1,
+					t2,
+					t3: tEnd
+				}, {
+					skipped: true,
+					cacheHit: false,
+					container
+				});
+			}
+			return null;
+		}
 		container.lastSvgHash = hash;
+		container._dupCount = 0;
 	}
 	const dataUri = bufferToDataUri(buffer, config.imageFormat);
+	if (config.caching && config.imageCacheMaxBytes > 0) {
+		if (treeHash === void 0 || cacheKey === void 0) {
+			treeHash = computeTreeHash(container);
+			cacheKey = computeCacheKey(treeHash, width, height, config.devicePixelRatio, config.imageFormat);
+		}
+		getImageCache(config.imageCacheMaxBytes).set(cacheKey, dataUri, dataUri.length * 2 + 64);
+	}
+	metrics.recordRender(t2 - t0);
+	if (profiling) {
+		const tEnd = performance.now();
+		emitProfile(config, {
+			t0,
+			t1,
+			t2,
+			t3: tEnd
+		}, {
+			skipped: false,
+			cacheHit: false,
+			container
+		});
+	}
 	config.onRender?.(container, dataUri);
 	return dataUri;
 }
 async function renderToRaw(container, width, height, config) {
 	if (container.children.length === 0) return null;
-	const { node, stylesheets } = await fromJsx(createElement("div", { style: {
-		display: "flex",
-		width: "100%",
-		height: "100%"
-	} }, ...container.children.map(vnodeToElement)));
-	const buffer = await config.renderer.render(node, {
-		width,
-		height,
-		format: "raw",
-		stylesheets,
-		devicePixelRatio: config.devicePixelRatio
-	});
+	metrics.recordFlush();
+	if (config.caching && !isContainerDirty(container)) {
+		metrics.recordDirtySkip();
+		return null;
+	}
+	const profiling = config.onProfile != null;
+	const t0 = profiling ? performance.now() : 0;
+	let t1 = t0;
+	let t2 = t0;
+	let treeHash;
+	let cacheKey;
+	if (config.caching && config.touchStripCacheMaxBytes > 0) {
+		treeHash = computeTreeHash(container);
+		cacheKey = computeCacheKey(treeHash, width, height, config.devicePixelRatio, "raw");
+		const cached = getTouchStripCache(config.touchStripCacheMaxBytes).get(cacheKey);
+		if (cached !== void 0) {
+			metrics.recordCacheHit();
+			if (profiling) {
+				const tNow = performance.now();
+				emitProfile(config, {
+					t0,
+					t1: tNow,
+					t2: tNow,
+					t3: tNow
+				}, {
+					skipped: false,
+					cacheHit: true,
+					container
+				});
+			}
+			return {
+				buffer: cached,
+				width,
+				height
+			};
+		}
+	}
+	let buffer;
+	if (config.renderPool?.isAvailable) {
+		buffer = await config.renderPool.render(container.children, width, height, "raw", config.devicePixelRatio);
+		t2 = profiling ? performance.now() : 0;
+		t1 = t0;
+	} else {
+		const rootNode = buildTakumiRoot(container);
+		t1 = profiling ? performance.now() : 0;
+		buffer = await config.renderer.render(rootNode, {
+			width,
+			height,
+			format: "raw",
+			devicePixelRatio: config.devicePixelRatio
+		});
+		t2 = profiling ? performance.now() : 0;
+	}
 	if (config.caching) {
 		const hash = fnv1a(buffer);
-		if (hash === container.lastSvgHash) return null;
+		if (hash === container.lastSvgHash) {
+			metrics.recordHashDedup();
+			if (profiling) {
+				const tEnd = performance.now();
+				emitProfile(config, {
+					t0,
+					t1,
+					t2,
+					t3: tEnd
+				}, {
+					skipped: true,
+					cacheHit: false,
+					container
+				});
+			}
+			return null;
+		}
 		container.lastSvgHash = hash;
 	}
+	const buf = Buffer.isBuffer(buffer) ? buffer : Buffer.from(buffer);
+	if (config.caching && config.touchStripCacheMaxBytes > 0) {
+		if (treeHash === void 0 || cacheKey === void 0) {
+			treeHash = computeTreeHash(container);
+			cacheKey = computeCacheKey(treeHash, width, height, config.devicePixelRatio, "raw");
+		}
+		getTouchStripCache(config.touchStripCacheMaxBytes).set(cacheKey, buf, buf.byteLength + 64);
+	}
+	metrics.recordRender(t2 - t0);
+	if (profiling) {
+		const tEnd = performance.now();
+		emitProfile(config, {
+			t0,
+			t1,
+			t2,
+			t3: tEnd
+		}, {
+			skipped: false,
+			cacheHit: false,
+			container
+		});
+	}
 	return {
-		buffer: Buffer.isBuffer(buffer) ? buffer : Buffer.from(buffer),
+		buffer: buf,
 		width,
 		height
 	};
 }
 function cropSlice(raw, fullWidth, column, segmentWidth, segmentHeight) {
-	const slice = Buffer.alloc(segmentWidth * segmentHeight * 4);
+	const pool = getBufferPool();
+	const sliceSize = segmentWidth * segmentHeight * 4;
+	const slice = pool.acquire(sliceSize);
 	const srcRowBytes = fullWidth * 4;
 	const dstRowBytes = segmentWidth * 4;
 	const xOffset = column * segmentWidth * 4;
@@ -68,7 +335,10 @@ function cropSlice(raw, fullWidth, column, segmentWidth, segmentHeight) {
 	return slice;
 }
 function sliceToDataUri(raw, fullWidth, fullHeight, column, segmentWidth, segmentHeight) {
-	return bufferToDataUri(encodePng(segmentWidth, segmentHeight, cropSlice(raw, fullWidth, column, segmentWidth, segmentHeight)), "png");
+	const cropped = cropSlice(raw, fullWidth, column, segmentWidth, segmentHeight);
+	const png = encodePng(segmentWidth, segmentHeight, cropped);
+	getBufferPool().release(cropped);
+	return bufferToDataUri(png, "png");
 }
 //#endregion
-export { bufferToDataUri, renderToDataUri, renderToRaw, sliceToDataUri };
+export { bufferToDataUri, buildTakumiRoot, measureTree, renderToDataUri, renderToRaw, sliceToDataUri };

package/dist/render/png.d.ts

@@ -1,5 +1,5 @@
 /**
- * Encode raw RGBA pixels into a PNG buffer.
+ * Encode raw RGBA pixels into a PNG buffer (synchronous).
  *
  * @param width  Image width in pixels.
  * @param height Image height in pixels.

package/dist/render/png.js

@@ -1,3 +1,4 @@
+import { getBufferPool } from "./buffer-pool.js";
 import { deflateSync } from "node:zlib";
 //#region src/render/png.ts
 var crcTable = new Uint32Array(256);
@@ -35,14 +36,7 @@ var PNG_SIGNATURE = Buffer.from([
 	26,
 	10
 ]);
-/**
-* Encode raw RGBA pixels into a PNG buffer.
-*
-* @param width  Image width in pixels.
-* @param height Image height in pixels.
-* @param rgba   Raw RGBA pixel data (width × height × 4 bytes, row-major).
-*/
-function encodePng(width, height, rgba) {
+function buildIhdr(width, height) {
 	const ihdr = Buffer.alloc(13);
 	ihdr.writeUInt32BE(width, 0);
 	ihdr.writeUInt32BE(height, 4);
@@ -51,15 +45,22 @@ function encodePng(width, height, rgba) {
 	ihdr[10] = 0;
 	ihdr[11] = 0;
 	ihdr[12] = 0;
+	return ihdr;
+}
+function buildFilteredScanlines(width, height, rgba) {
 	const rowBytes = width * 4;
-	const filtered = Buffer.alloc(height * (1 + rowBytes));
+	const filteredSize = height * (1 + rowBytes);
+	const filtered = getBufferPool().acquire(filteredSize);
 	for (let y = 0; y < height; y++) {
 		const dstOff = y * (1 + rowBytes);
 		filtered[dstOff] = 0;
 		const srcOff = y * rowBytes;
-		for (let i = 0; i < rowBytes; i++) filtered[dstOff + 1 + i] = rgba[srcOff + i];
+		if (Buffer.isBuffer(rgba)) rgba.copy(filtered, dstOff + 1, srcOff, srcOff + rowBytes);
+		else filtered.set(rgba.subarray(srcOff, srcOff + rowBytes), dstOff + 1);
 	}
-	const compressed = deflateSync(filtered);
+	return filtered;
+}
+function assemblePng(ihdr, compressed) {
 	return Buffer.concat([
 		PNG_SIGNATURE,
 		pngChunk("IHDR", ihdr),
@@ -67,5 +68,19 @@ function encodePng(width, height, rgba) {
 		pngChunk("IEND", Buffer.alloc(0))
 	]);
 }
+/**
+* Encode raw RGBA pixels into a PNG buffer (synchronous).
+*
+* @param width  Image width in pixels.
+* @param height Image height in pixels.
+* @param rgba   Raw RGBA pixel data (width × height × 4 bytes, row-major).
+*/
+function encodePng(width, height, rgba) {
+	const ihdr = buildIhdr(width, height);
+	const filtered = buildFilteredScanlines(width, height, rgba);
+	const compressed = deflateSync(filtered);
+	getBufferPool().release(filtered);
+	return assemblePng(ihdr, compressed);
+}
 //#endregion
 export { encodePng };

package/dist/render/render-pool.d.ts

@@ -0,0 +1,24 @@
+import { FontConfig } from '../types';
+import { VNode } from '../reconciler/vnode';
+export declare class RenderPool {
+    private worker;
+    private ready;
+    private failed;
+    private nextId;
+    private pending;
+    private initPromise;
+    private fonts;
+    constructor(fonts: FontConfig[]);
+    /** Start the worker. Call once during plugin initialization. */
+    initialize(): Promise<boolean>;
+    private doInitialize;
+    /** Whether the worker is available for offloaded rendering. */
+    get isAvailable(): boolean;
+    /**
+     * Render VNode children in the worker thread.
+     * Returns the raw raster buffer.
+     */
+    render(vnodes: VNode[], width: number, height: number, format: string, dpr: number): Promise<Buffer>;
+    private handleResponse;
+    private handleWorkerDeath;
+}

package/dist/render/render-pool.js

@@ -0,0 +1,130 @@
+import { Worker } from "node:worker_threads";
+//#region src/render/render-pool.ts
+/** Strip internal fields and function props from a VNode tree for worker transfer. */
+function serializeVNode(node) {
+	const cleanProps = {};
+	for (const [key, value] of Object.entries(node.props)) if (typeof value !== "function" && typeof value !== "symbol") cleanProps[key] = value;
+	return {
+		type: node.type,
+		props: cleanProps,
+		children: node.children.map(serializeVNode),
+		text: node.text
+	};
+}
+var RenderPool = class {
+	worker = null;
+	ready = false;
+	failed = false;
+	nextId = 0;
+	pending = /* @__PURE__ */ new Map();
+	initPromise = null;
+	fonts;
+	constructor(fonts) {
+		this.fonts = fonts;
+	}
+	/** Start the worker. Call once during plugin initialization. */
+	async initialize() {
+		if (this.ready) return true;
+		if (this.failed) return false;
+		if (this.initPromise != null) {
+			await this.initPromise;
+			return this.ready;
+		}
+		this.initPromise = this.doInitialize();
+		await this.initPromise;
+		return this.ready;
+	}
+	async doInitialize() {
+		try {
+			this.worker = new Worker(new URL("data:video/mp2t;base64,// ── Render Worker ────────────────────────────────────────────────────
//
// Runs in a separate thread via Node.js worker_threads.  Handles the
// full render pipeline: serialized VNode data → Takumi nodes → raster.
//
// Uses the direct VNode → Takumi node bypass (same as main thread's
// vnodeToTakumiNode in pipeline.ts), skipping vnodeToElement() and
// fromJsx() entirely.
//
// This unblocks the main thread during the expensive Takumi
// rasterization step (~5–30ms per frame).
//
// Why code is duplicated (inlined):
//   Worker threads can't import from the main bundle — they load
//   the compiled worker.js file independently.  SVG serialization
//   and VNode→Takumi conversion must be self-contained here.
//   Both mirror the logic in svg.ts and pipeline.ts respectively.
//
// Zero-copy return:
//   The rendered buffer is transferred (not copied) back to the main
//   thread via postMessage's transfer list.  This avoids copying
//   potentially large raster buffers (e.g. 800×100×4 = 320KB for
//   TouchStrip) across the thread boundary.

import { parentPort, workerData } from "node:worker_threads";

// ── Types ───────────────────────────────────────────────────────────

interface SerializedVNode {
  type: string;
  props: Record<string, unknown>;
  children: SerializedVNode[];
  text?: string;
}

/** Matches @takumi-rs/helpers Node union. Plain object accepted by Renderer.render(). */
interface TakumiNode {
  type: string;
  [key: string]: unknown;
}

interface InitMessage {
  type: "init";
  fonts: Array<{
    name: string;
    data: ArrayBuffer | Buffer;
    weight: number;
    style: string;
  }>;
}

interface RenderMessage {
  type: "render";
  id: number;
  vnodes: SerializedVNode[];
  width: number;
  height: number;
  format: string;
  dpr: number;
}

interface ShutdownMessage {
  type: "shutdown";
}

type WorkerMessage = InitMessage | RenderMessage | ShutdownMessage;

// ── SVG Serialization (inlined for worker context) ──────────────────
// Mirrors the serializeSvgTree() from svg.ts. Inlined to avoid
// cross-module import issues in the worker thread.

const SVG_CAMEL_ATTRS: ReadonlySet<string> = new Set([
  "accentHeight",
  "alignmentBaseline",
  "arabicForm",
  "baselineShift",
  "capHeight",
  "clipPath",
  "clipPathUnits",
  "clipRule",
  "colorInterpolation",
  "colorInterpolationFilters",
  "colorProfile",
  "colorRendering",
  "enableBackground",
  "fillOpacity",
  "fillRule",
  "floodColor",
  "floodOpacity",
  "fontFamily",
  "fontSize",
  "fontSizeAdjust",
  "fontStretch",
  "fontStyle",
  "fontVariant",
  "fontWeight",
  "glyphName",
  "glyphOrientationHorizontal",
  "glyphOrientationVertical",
  "horizAdvX",
  "horizOriginX",
  "imageRendering",
  "letterSpacing",
  "lightingColor",
  "markerEnd",
  "markerMid",
  "markerStart",
  "overlinePosition",
  "overlineThickness",
  "paintOrder",
  "pointerEvents",
  "preserveAspectRatio",
  "shapeRendering",
  "stopColor",
  "stopOpacity",
  "strokeDasharray",
  "strokeDashoffset",
  "strokeLinecap",
  "strokeLinejoin",
  "strokeMiterlimit",
  "strokeOpacity",
  "strokeWidth",
  "textAnchor",
  "textDecoration",
  "textRendering",
  "transformOrigin",
  "underlinePosition",
  "underlineThickness",
  "unicodeBidi",
  "unicodeRange",
  "unitsPerEm",
  "vAlphabetic",
  "vHanging",
  "vIdeographic",
  "vMathematical",
  "vectorEffect",
  "vertAdvY",
  "vertOriginX",
  "vertOriginY",
  "wordSpacing",
  "writingMode",
]);

const SVG_SKIP_PROPS: ReadonlySet<string> = new Set([
  "children",
  "key",
  "ref",
  "__self",
  "__source",
]);

function camelToKebab(str: string): string {
  return str.replace(/[A-Z]/g, (ch) => `-${ch.toLowerCase()}`);
}

function escapeAttr(value: string): string {
  return value
    .replace(/&/g, "&amp;")
    .replace(/"/g, "&quot;")
    .replace(/</g, "&lt;")
    .replace(/>/g, "&gt;");
}

function serializeSvgStyle(style: Record<string, unknown>): string {
  const parts: string[] = [];
  for (const key of Object.keys(style)) {
    const value = style[key];
    if (value == null) continue;
    parts.push(`${camelToKebab(key)}:${String(value).trim()}`);
  }
  return parts.join(";");
}

function serializeSvgAttr(key: string, value: unknown): string | null {
  if (SVG_SKIP_PROPS.has(key) || value == null) return null;
  let attrName: string;
  if (key === "className") attrName = "class";
  else if (SVG_CAMEL_ATTRS.has(key)) attrName = camelToKebab(key);
  else attrName = key;
  if (key === "style" && typeof value === "object") {
    const css = serializeSvgStyle(value as Record<string, unknown>);
    if (!css) return null;
    return `${attrName}="${escapeAttr(css)}"`;
  }
  if (typeof value === "boolean") return `${attrName}="${String(value)}"`;
  return `${attrName}="${escapeAttr(String(value))}"`;
}

function serializeSvgVNode(node: SerializedVNode): string {
  if (node.type === "#text") return node.text ?? "";
  const attrs: string[] = [];
  for (const [key, value] of Object.entries(node.props)) {
    const attr = serializeSvgAttr(key, value);
    if (attr != null) attrs.push(attr);
  }
  const childMarkup = node.children.map(serializeSvgVNode).join("");
  const attrStr = attrs.length > 0 ? ` ${attrs.join(" ")}` : "";
  return `<${node.type}${attrStr}>${childMarkup}</${node.type}>`;
}

function serializeSvgTree(svgNode: SerializedVNode): string {
  if (!("xmlns" in svgNode.props)) {
    const augmented = {
      ...svgNode,
      props: { ...svgNode.props, xmlns: "http://www.w3.org/2000/svg" },
    };
    return serializeSvgVNode(augmented);
  }
  return serializeSvgVNode(svgNode);
}

// ── Direct VNode → Takumi Node Conversion ───────────────────────────
// Mirrors the main-thread vnodeToTakumiNode() from pipeline.ts.
// Inlined to avoid cross-module import issues in worker context.

function vnodeToTakumiNode(node: SerializedVNode): TakumiNode {
  // Text nodes → Takumi TextNode
  if (node.type === "#text") {
    return { type: "text", text: node.text ?? "" };
  }

  const { children: _children, className, src, ...restProps } = node.props;

  // Map className → tw (same logic as main thread)
  let tw: string | undefined = typeof restProps.tw === "string" ? restProps.tw : undefined;
  if (typeof className === "string" && className.length > 0) {
    tw = tw ? tw + " " + className : className;
  }

  // Image nodes → Takumi ImageNode
  if (node.type === "img" && typeof src === "string") {
    return {
      type: "image",
      src: src as string,
      ...(tw ? { tw } : {}),
      ...restProps,
    };
  }

  // SVG nodes → Takumi ImageNode (serialize subtree to SVG markup)
  if (node.type === "svg") {
    const svgMarkup = serializeSvgTree(node);
    const width = typeof node.props.width === "number" ? node.props.width : undefined;
    const height = typeof node.props.height === "number" ? node.props.height : undefined;
    return {
      type: "image",
      src: svgMarkup,
      ...(width != null ? { width } : {}),
      ...(height != null ? { height } : {}),
      ...(tw ? { tw } : {}),
      ...(node.props.style ? { style: node.props.style } : {}),
      tagName: "svg",
    };
  }

  // All other nodes → Takumi ContainerNode
  const takumiChildren =
    node.children.length > 0 ? node.children.map(vnodeToTakumiNode) : undefined;

  return {
    type: "container",
    ...(tw ? { tw } : {}),
    ...restProps,
    ...(takumiChildren ? { children: takumiChildren } : {}),
  };
}

// ── Root style constant ─────────────────────────────────────────────

const ROOT_STYLE = { display: "flex", width: "100%", height: "100%" } as const;

// ── Worker State ────────────────────────────────────────────────────

let renderer: import("@takumi-rs/core").Renderer | null = null;

// ── Message Handler ─────────────────────────────────────────────────

async function handleMessage(msg: WorkerMessage): Promise<void> {
  switch (msg.type) {
    case "init": {
      try {
        // Dynamic import — may fail if the native addon can't load in a worker
        const core = await import("@takumi-rs/core");

        renderer = new core.Renderer({
          fonts: msg.fonts.map((f) => ({
            name: f.name,
            data: f.data,
            weight: f.weight as 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900,
            style: f.style as "normal" | "italic",
          })),
        });

        parentPort!.postMessage({ type: "ready" });
      } catch (err) {
        parentPort!.postMessage({
          type: "error",
          id: -1,
          error: `Worker init failed: ${err instanceof Error ? err.message : String(err)}`,
        });
      }
      break;
    }

    case "render": {
      if (renderer == null) {
        parentPort!.postMessage({
          type: "error",
          id: msg.id,
          error: "Worker not initialized",
        });
        return;
      }

      try {
        // 1. Convert serialized VNode data → Takumi nodes directly (bypass fromJsx)
        const children = msg.vnodes.map(vnodeToTakumiNode);
        const rootNode: TakumiNode = {
          type: "container",
          style: ROOT_STYLE,
          children,
        };

        // 2. Render to raster image
        const buffer = await renderer.render(rootNode, {
          width: msg.width,
          height: msg.height,
          format: msg.format as import("@takumi-rs/core").OutputFormat,
          devicePixelRatio: msg.dpr,
        });

        // Transfer the buffer (zero-copy) back to the main thread
        const ab =
          buffer instanceof ArrayBuffer
            ? buffer
            : buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);

        parentPort!.postMessage(
          { type: "result", id: msg.id, buffer: ab },
          { transfer: [ab as ArrayBuffer] },
        );
      } catch (err) {
        parentPort!.postMessage({
          type: "error",
          id: msg.id,
          error: err instanceof Error ? err.message : String(err),
        });
      }
      break;
    }

    case "shutdown": {
      process.exit(0);
    }
  }
}

// ── Auto-init if fonts provided via workerData ──────────────────────

if (workerData?.fonts) {
  handleMessage({ type: "init", fonts: workerData.fonts });
}

parentPort!.on("message", (msg: WorkerMessage) => {
  handleMessage(msg);
});
", "" + import.meta.url), { workerData: { fonts: this.fonts.map((f) => ({
+				name: f.name,
+				data: f.data,
+				weight: f.weight,
+				style: f.style
+			})) } });
+			await new Promise((resolve, reject) => {
+				const timeout = setTimeout(() => {
+					reject(/* @__PURE__ */ new Error("Worker initialization timed out (5s)"));
+				}, 5e3);
+				const onMessage = (msg) => {
+					if (msg.type === "ready") {
+						clearTimeout(timeout);
+						this.worker.off("message", onMessage);
+						this.worker.off("error", onError);
+						resolve();
+					} else if (msg.type === "error" && msg.id === -1) {
+						clearTimeout(timeout);
+						this.worker.off("message", onMessage);
+						this.worker.off("error", onError);
+						reject(new Error(msg.error ?? "Unknown worker init error"));
+					}
+				};
+				const onError = (err) => {
+					clearTimeout(timeout);
+					reject(err);
+				};
+				this.worker.on("message", onMessage);
+				this.worker.on("error", onError);
+			});
+			this.worker.on("message", this.handleResponse.bind(this));
+			this.worker.on("exit", (code) => {
+				if (code !== 0) console.warn(`[@fcannizzaro/streamdeck-react] Render worker exited with code ${code}`);
+				this.handleWorkerDeath();
+			});
+			this.worker.on("error", (err) => {
+				console.error("[@fcannizzaro/streamdeck-react] Render worker error:", err);
+				this.handleWorkerDeath();
+			});
+			this.ready = true;
+		} catch (err) {
+			console.warn("[@fcannizzaro/streamdeck-react] Worker initialization failed, falling back to main-thread rendering:", err instanceof Error ? err.message : err);
+			this.failed = true;
+			this.worker?.terminate().catch(() => {});
+			this.worker = null;
+		}
+	}
+	/** Whether the worker is available for offloaded rendering. */
+	get isAvailable() {
+		return this.ready && this.worker != null;
+	}
+	/**
+	* Render VNode children in the worker thread.
+	* Returns the raw raster buffer.
+	*/
+	async render(vnodes, width, height, format, dpr) {
+		if (!this.isAvailable) throw new Error("Worker not available");
+		const id = this.nextId++;
+		const serialized = vnodes.map(serializeVNode);
+		return new Promise((resolve, reject) => {
+			this.pending.set(id, {
+				resolve,
+				reject
+			});
+			this.worker.postMessage({
+				type: "render",
+				id,
+				vnodes: serialized,
+				width,
+				height,
+				format,
+				dpr
+			});
+		});
+	}
+	handleResponse(msg) {
+		if (msg.type === "ready") return;
+		const req = this.pending.get(msg.id);
+		if (req == null) return;
+		this.pending.delete(msg.id);
+		if (msg.type === "result" && msg.buffer != null) req.resolve(Buffer.from(msg.buffer));
+		else if (msg.type === "error") req.reject(new Error(msg.error ?? "Unknown worker render error"));
+	}
+	handleWorkerDeath() {
+		this.ready = false;
+		this.worker = null;
+		for (const [_, req] of this.pending) req.reject(/* @__PURE__ */ new Error("Worker died unexpectedly"));
+		this.pending.clear();
+	}
+};
+//#endregion
+export { RenderPool };

package/dist/render/svg.d.ts

@@ -0,0 +1,7 @@
+import { VNode } from '../reconciler/vnode';
+/**
+ * Serialize an `<svg>` VNode (and its entire subtree) to an SVG markup string.
+ * Auto-injects `xmlns="http://www.w3.org/2000/svg"` if not present.
+ * The returned string can be used as the `src` of a Takumi ImageNode.
+ */
+export declare function serializeSvgTree(svgNode: VNode): string;