@fcannizzaro/streamdeck-react 0.1.9 → 0.1.11

package/dist/render/render-pool.js

@@ -0,0 +1,141 @@
+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
+			});
+		});
+	}
+	/** Gracefully shut down the worker. */
+	async shutdown() {
+		if (this.worker != null) {
+			for (const [_, req] of this.pending) req.reject(/* @__PURE__ */ new Error("Worker shutting down"));
+			this.pending.clear();
+			this.worker.postMessage({ type: "shutdown" });
+			await this.worker.terminate();
+			this.worker = null;
+		}
+		this.ready = false;
+	}
+	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;

package/dist/render/svg.js

@@ -0,0 +1,139 @@
+//#region src/render/svg.ts
+var SVG_CAMEL_ATTRS = 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"
+]);
+var SKIP_PROPS = new Set([
+	"children",
+	"key",
+	"ref",
+	"__self",
+	"__source"
+]);
+function camelToKebab(str) {
+	return str.replace(/[A-Z]/g, (ch) => `-${ch.toLowerCase()}`);
+}
+function escapeAttr(value) {
+	return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function serializeStyle(style) {
+	const parts = [];
+	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 serializeAttr(key, value) {
+	if (SKIP_PROPS.has(key) || value == null) return null;
+	let attrName;
+	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 = serializeStyle(value);
+		if (!css) return null;
+		return `${attrName}="${escapeAttr(css)}"`;
+	}
+	if (typeof value === "boolean") return `${attrName}="${String(value)}"`;
+	return `${attrName}="${escapeAttr(String(value))}"`;
+}
+function serializeVNode(node) {
+	if (node.type === "#text") return node.text ?? "";
+	const attrs = [];
+	for (const [key, value] of Object.entries(node.props)) {
+		const attr = serializeAttr(key, value);
+		if (attr != null) attrs.push(attr);
+	}
+	const childMarkup = node.children.map(serializeVNode).join("");
+	const attrStr = attrs.length > 0 ? ` ${attrs.join(" ")}` : "";
+	return `<${node.type}${attrStr}>${childMarkup}</${node.type}>`;
+}
+/**
+* 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.
+*/
+function serializeSvgTree(svgNode) {
+	if (!("xmlns" in svgNode.props)) {
+		const original = svgNode.props;
+		svgNode.props = {
+			...original,
+			xmlns: "http://www.w3.org/2000/svg"
+		};
+		const result = serializeVNode(svgNode);
+		svgNode.props = original;
+		return result;
+	}
+	return serializeVNode(svgNode);
+}
+//#endregion
+export { serializeSvgTree };

package/dist/render/worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/rollup.d.ts

@@ -1,16 +1,30 @@
 import { Plugin } from 'rollup';
 import { StreamDeckTargetOptions } from './bundler-shared';
 export type { StreamDeckPlatform, StreamDeckArch, StreamDeckTarget, StreamDeckTargetOptions, } from './bundler-shared';
+export interface StreamDeckRollupOptions extends StreamDeckTargetOptions {
+    /**
+     * Path to the plugin `manifest.json`. When omitted, the plugin
+     * auto-detects by scanning the project root for a `*.sdPlugin/manifest.json`.
+     *
+     * Set to `false` to disable manifest type generation entirely.
+     */
+    manifest?: string | false;
+}
 /**
- * Rollup plugin that copies the `@takumi-rs/core` platform-specific native
- * binding (`.node` file) into the bundle output directory so the Stream Deck
- * Node.js runtime can find it at startup.
+ * Rollup plugin for Stream Deck React projects.
  *
- * Font files (`.ttf`, `.otf`, `.woff`, `.woff2`) imported by the project are
- * automatically inlined into the bundle as `Buffer` instances so no runtime
- * filesystem access is needed.
+ * Same responsibilities as the Vite plugin (see vite.ts) with
+ * Rollup-specific differences:
  *
- * In production builds (non-watch mode), the devtools module is replaced with
- * a noop stub so the entire devtools tree and `ws` dependency are eliminated.
+ *   - No `configResolved` — dev mode detected via `this.meta.watchMode`
+ *   - `onLog` suppresses `MODULE_LEVEL_DIRECTIVE` warnings (caused by
+ *     "use client" directives in React dependencies)
+ *   - `buildStart` resolves root via `resolve(".")` (no Vite config)
+ *   - `writeBundle` reads output dir from `outputOptions.dir` or
+ *     `dirname(outputOptions.file)` (Rollup supports both)
+ *   - No `closeBundle` restart hook (handled externally)
+ *
+ * Font inlining and manifest codegen are shared via bundler-shared.ts,
+ * font-inline.ts, and manifest-codegen.ts.
  */
-export declare function streamDeckReact(options?: StreamDeckTargetOptions): Plugin;
+export declare function streamDeckReact(options?: StreamDeckRollupOptions): Plugin;

package/dist/rollup.js

@@ -1,18 +1,24 @@
 import { NOOP_DEVTOOLS_CODE, NOOP_DEVTOOLS_ID, copyNativeBindings, isDevelopmentMode, isLibraryDevtoolsImport, shouldStripDevtools } from "./bundler-shared.js";
 import { loadFont, resolveFontId } from "./font-inline.js";
-import { dirname } from "node:path";
+import { generateManifestTypes } from "./manifest-codegen.js";
+import { dirname, resolve } from "node:path";
 //#region src/rollup.ts
 /**
-* Rollup plugin that copies the `@takumi-rs/core` platform-specific native
-* binding (`.node` file) into the bundle output directory so the Stream Deck
-* Node.js runtime can find it at startup.
+* Rollup plugin for Stream Deck React projects.
 *
-* Font files (`.ttf`, `.otf`, `.woff`, `.woff2`) imported by the project are
-* automatically inlined into the bundle as `Buffer` instances so no runtime
-* filesystem access is needed.
+* Same responsibilities as the Vite plugin (see vite.ts) with
+* Rollup-specific differences:
 *
-* In production builds (non-watch mode), the devtools module is replaced with
-* a noop stub so the entire devtools tree and `ws` dependency are eliminated.
+*   - No `configResolved` — dev mode detected via `this.meta.watchMode`
+*   - `onLog` suppresses `MODULE_LEVEL_DIRECTIVE` warnings (caused by
+*     "use client" directives in React dependencies)
+*   - `buildStart` resolves root via `resolve(".")` (no Vite config)
+*   - `writeBundle` reads output dir from `outputOptions.dir` or
+*     `dirname(outputOptions.file)` (Rollup supports both)
+*   - No `closeBundle` restart hook (handled externally)
+*
+* Font inlining and manifest codegen are shared via bundler-shared.ts,
+* font-inline.ts, and manifest-codegen.ts.
 */
 function streamDeckReact(options = {}) {
 	return {
@@ -20,6 +26,15 @@ function streamDeckReact(options = {}) {
 		onLog(_level, log) {
 			if (log.code === "MODULE_LEVEL_DIRECTIVE") return false;
 		},
+		buildStart() {
+			const root = resolve(".");
+			const warn = (msg) => this.warn(msg);
+			const result = generateManifestTypes(root, options.manifest, warn);
+			if (result) {
+				this.addWatchFile(result.manifestPath);
+				if (result.written) console.log("[@fcannizzaro/streamdeck-react] Generated src/streamdeck-env.d.ts");
+			}
+		},
 		resolveId: {
 			order: "pre",
 			handler(source, importer) {

package/dist/roots/flush-coordinator.d.ts

@@ -0,0 +1,18 @@
+/** Any root that can participate in prioritized flushing. */
+export interface FlushableRoot {
+    /** Current render priority. 0 = animating (highest), 3 = idle (lowest). */
+    readonly priority: number;
+    /** Execute the flush (render + push to hardware). */
+    executeFlush(): Promise<void>;
+}
+export declare class FlushCoordinator {
+    private pending;
+    private scheduled;
+    private draining;
+    /**
+     * Enqueue a root for flushing. Flushes are batched via microtask
+     * and processed in priority order.
+     */
+    requestFlush(root: FlushableRoot): void;
+    private drain;
+}

package/dist/roots/flush-coordinator.js

@@ -0,0 +1,38 @@
+//#region src/roots/flush-coordinator.ts
+var FlushCoordinator = class {
+	pending = /* @__PURE__ */ new Set();
+	scheduled = false;
+	draining = false;
+	/**
+	* Enqueue a root for flushing. Flushes are batched via microtask
+	* and processed in priority order.
+	*/
+	requestFlush(root) {
+		this.pending.add(root);
+		if (!this.scheduled && !this.draining) {
+			this.scheduled = true;
+			queueMicrotask(() => this.drain());
+		}
+	}
+	async drain() {
+		this.scheduled = false;
+		if (this.draining || this.pending.size === 0) return;
+		this.draining = true;
+		try {
+			while (this.pending.size > 0) {
+				const roots = [...this.pending];
+				this.pending.clear();
+				roots.sort((a, b) => a.priority - b.priority);
+				for (const root of roots) await root.executeFlush();
+			}
+		} finally {
+			this.draining = false;
+			if (this.pending.size > 0 && !this.scheduled) {
+				this.scheduled = true;
+				queueMicrotask(() => this.drain());
+			}
+		}
+	}
+};
+//#endregion
+export { FlushCoordinator };

package/dist/roots/registry.d.ts

@@ -6,24 +6,26 @@ import { RenderConfig } from '../render/pipeline';
 import { RegistryObserver } from '../devtools/observers/lifecycle';
 export declare class RootRegistry {
     private roots;
-    private touchBarRoots;
-    private touchBarActions;
+    private touchStripRoots;
+    private touchStripActions;
     private renderConfig;
     private renderDebounceMs;
     private sdkInstance;
     private globalSettings;
     private onGlobalSettingsChange;
     private wrapper?;
+    private flushCoordinator;
     /** DevTools observer. Set externally by startDevtoolsServer(). null when devtools is off. */
     observer: RegistryObserver | null;
     constructor(renderConfig: RenderConfig, renderDebounceMs: number, sdkInstance: StreamDeckAccess["sdk"], onGlobalSettingsChange: (settings: JsonObject) => Promise<void>, wrapper?: WrapperComponent);
     setGlobalSettings(settings: JsonObject): void;
     create(ev: WillAppearEvent<JsonObject>, component: ComponentType, definition: ActionDefinition): void;
-    private registerTouchBarColumn;
+    private registerTouchStripColumn;
     private getEncoderColumn;
     destroy(contextId: string): void;
+    private static readonly INTERACTION_EVENTS;
     dispatch<K extends keyof EventMap>(contextId: string, event: K, payload: EventMap[K]): void;
-    private dispatchToTouchBar;
+    private dispatchToTouchStrip;
     updateSettings(contextId: string, settings: JsonObject): void;
     destroyAll(): void;
 }