@fcannizzaro/streamdeck-react 0.1.11 → 0.1.13

package/dist/google-font.js

@@ -0,0 +1,124 @@
+import { access, mkdir, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+//#region src/google-font.ts
+var TTF_USER_AGENT = "Mozilla/4.0";
+var GOOGLE_FONTS_CSS2_BASE = "https://fonts.googleapis.com/css2";
+var CACHE_DIR = ".google-fonts";
+function sanitizeName(family) {
+	return family.toLowerCase().replace(/\s+/g, "-");
+}
+function cacheFilePath(family, weight, style) {
+	return join(process.cwd(), CACHE_DIR, `${sanitizeName(family)}-${weight}-${style}.ttf`);
+}
+async function fileExists(path) {
+	try {
+		await access(path);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function ensureCacheDir() {
+	await mkdir(join(process.cwd(), CACHE_DIR), { recursive: true });
+}
+async function readCached(family, weight, style) {
+	const path = cacheFilePath(family, weight, style);
+	if (!await fileExists(path)) return null;
+	return {
+		name: family,
+		data: (await readFile(path)).buffer,
+		weight,
+		style
+	};
+}
+async function writeCache(family, weight, style, data) {
+	await ensureCacheDir();
+	await writeFile(cacheFilePath(family, weight, style), Buffer.from(data));
+}
+function buildCss2Url(family, variants) {
+	const hasItalic = variants.some((v) => v.style === "italic");
+	const encodedFamily = encodeURIComponent(family);
+	if (hasItalic) {
+		const specs = variants.map((v) => {
+			return `${v.style === "italic" ? 1 : 0},${v.weight ?? 400}`;
+		});
+		specs.sort();
+		return `${GOOGLE_FONTS_CSS2_BASE}?family=${encodedFamily}:ital,wght@${specs.join(";")}`;
+	}
+	const weights = variants.map((v) => v.weight ?? 400);
+	weights.sort((a, b) => a - b);
+	return `${GOOGLE_FONTS_CSS2_BASE}?family=${encodedFamily}:wght@${weights.join(";")}`;
+}
+function parseFontFaces(css) {
+	const results = [];
+	const seen = /* @__PURE__ */ new Set();
+	const blockRegex = /@font-face\s*\{([^}]+)\}/g;
+	let match;
+	while ((match = blockRegex.exec(css)) !== null) {
+		const block = match[1];
+		const urlMatch = block.match(/url\(([^)]+)\)/);
+		const weightMatch = block.match(/font-weight:\s*(\d+)/);
+		const styleMatch = block.match(/font-style:\s*(normal|italic)/);
+		if (!urlMatch?.[1]) continue;
+		const weight = Number(weightMatch?.[1] ?? 400);
+		const style = styleMatch?.[1] ?? "normal";
+		const key = `${weight}:${style}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		results.push({
+			url: urlMatch[1],
+			weight,
+			style
+		});
+	}
+	return results;
+}
+async function fetchGoogleFonts(family, variants) {
+	const results = [];
+	const uncached = [];
+	for (const v of variants) {
+		const weight = v.weight ?? 400;
+		const style = v.style ?? "normal";
+		const cached = await readCached(family, weight, style);
+		if (cached) results.push(cached);
+		else uncached.push({
+			weight,
+			style
+		});
+	}
+	if (uncached.length === 0) return results;
+	const url = buildCss2Url(family, uncached);
+	const cssResponse = await fetch(url, { headers: { "User-Agent": TTF_USER_AGENT } });
+	if (!cssResponse.ok) throw new Error(`Google Fonts: failed to fetch CSS for "${family}" (HTTP ${cssResponse.status})`);
+	const faces = parseFontFaces(await cssResponse.text());
+	if (faces.length === 0) throw new Error(`Google Fonts: no font faces found in CSS response for "${family}". Verify the family name is correct at https://fonts.google.com`);
+	const downloaded = await Promise.all(faces.map(async (face) => {
+		const fontResponse = await fetch(face.url);
+		if (!fontResponse.ok) throw new Error(`Google Fonts: failed to download font file for "${family}" weight ${face.weight} (HTTP ${fontResponse.status})`);
+		const data = await fontResponse.arrayBuffer();
+		writeCache(family, face.weight, face.style, data).catch(() => {});
+		return {
+			name: family,
+			data,
+			weight: face.weight,
+			style: face.style
+		};
+	}));
+	return [...results, ...downloaded];
+}
+async function googleFont(family, variantOrVariants) {
+	if (variantOrVariants === void 0) return (await fetchGoogleFonts(family, [{
+		weight: 400,
+		style: "normal"
+	}]))[0];
+	if (!Array.isArray(variantOrVariants)) return (await fetchGoogleFonts(family, [{
+		weight: variantOrVariants.weight ?? 400,
+		style: variantOrVariants.style ?? "normal"
+	}]))[0];
+	return fetchGoogleFonts(family, variantOrVariants.map((v) => ({
+		weight: v.weight ?? 400,
+		style: v.style ?? "normal"
+	})));
+}
+//#endregion
+export { googleFont };

package/dist/hooks/animation.d.ts

@@ -35,7 +35,7 @@ export interface TweenConfig {
     duration: number;
     /** Easing function name or custom (t: number) => number. @default "easeOut" */
     easing: EasingName | EasingFn;
-    /** Target FPS for the animation tick loop. @default 60 */
+    /** Target FPS for the animation tick loop. @default 30 */
     fps: number;
 }
 export interface TweenResult<T extends AnimationTarget> {

package/dist/hooks/animation.js

@@ -12,7 +12,7 @@ var SPRING_DEFAULTS = {
 var TWEEN_DEFAULTS = {
 	duration: 300,
 	easing: "easeOut",
-	fps: 60
+	fps: 30
 };
 /** Max dt cap to prevent spring explosion after long pauses.
 *  If the process is suspended (debugger, GC pause), dt could be
@@ -196,7 +196,7 @@ function useSpring(target, config) {
 		config?.displacementThreshold,
 		config?.clamp
 	]);
-	const fps = config?.fps ?? 60;
+	const fps = config?.fps ?? 30;
 	const isObject = typeof target === "object" && target !== null;
 	const stateRef = useRef(null);
 	if (stateRef.current === null) stateRef.current = initializeSpringState(target);

package/dist/hooks/events.js

@@ -38,7 +38,7 @@ function useTouchTap(callback) {
 function useDialHint(hints) {
 	const { action } = useContext(StreamDeckContext);
 	useEffect(() => {
-		if ("setTriggerDescription" in action) action.setTriggerDescription({
+		action.setTriggerDescription({
 			rotate: hints.rotate,
 			push: hints.press,
 			touch: hints.touch,

package/dist/hooks/sdk.js

@@ -3,23 +3,23 @@ import { useCallbackRef } from "./internal/useCallbackRef.js";
 import { useCallback, useContext, useEffect } from "react";
 //#region src/hooks/sdk.ts
 function useOpenUrl() {
-	const { sdk } = useContext(StreamDeckContext);
+	const { adapter } = useContext(StreamDeckContext);
 	return useCallback(async (url) => {
-		await sdk.system.openUrl(url);
-	}, [sdk]);
+		await adapter.openUrl(url);
+	}, [adapter]);
 }
 function useSwitchProfile() {
-	const { sdk, action } = useContext(StreamDeckContext);
+	const { adapter, action } = useContext(StreamDeckContext);
 	return useCallback(async (profile, deviceId) => {
 		const devId = deviceId ?? action.device.id;
-		await sdk.profiles.switchToProfile(devId, profile);
-	}, [sdk, action]);
+		await adapter.switchToProfile(devId, profile);
+	}, [adapter, action]);
 }
 function useSendToPI() {
-	const { sdk } = useContext(StreamDeckContext);
+	const { adapter } = useContext(StreamDeckContext);
 	return useCallback(async (payload) => {
-		await sdk.ui.sendToPropertyInspector(payload);
-	}, [sdk]);
+		await adapter.sendToPropertyInspector(payload);
+	}, [adapter]);
 }
 function usePropertyInspector(callback) {
 	const bus = useContext(EventBusContext);
@@ -41,13 +41,13 @@ function useShowAlert() {
 function useShowOk() {
 	const { action } = useContext(StreamDeckContext);
 	return useCallback(async () => {
-		if ("showOk" in action) await action.showOk();
+		await action.showOk();
 	}, [action]);
 }
 function useTitle() {
 	const { action } = useContext(StreamDeckContext);
 	return useCallback(async (title) => {
-		if ("setTitle" in action) await action.setTitle(title);
+		await action.setTitle(title);
 	}, [action]);
 }
 //#endregion

package/dist/hooks/utility.js

@@ -1,10 +1,11 @@
 import { useCallbackRef } from "./internal/useCallbackRef.js";
 import { useCallback, useEffect, useMemo, useRef } from "react";
 //#region src/hooks/utility.ts
-var DEFAULT_TICK_FPS = 60;
+var DEFAULT_TICK_FPS = 30;
+var MAX_TICK_FPS = 30;
 function toTickIntervalMs(fps) {
 	if (!Number.isFinite(fps) || fps <= 0) return Math.round(1e3 / DEFAULT_TICK_FPS);
-	return Math.max(1, Math.round(1e3 / fps));
+	return Math.max(1, Math.round(1e3 / Math.min(fps, MAX_TICK_FPS)));
 }
 function useInterval(callback, delayMs) {
 	const callbackRef = useCallbackRef(callback);

package/dist/index.d.ts

@@ -3,6 +3,8 @@ export { defineAction } from './action';
 export type { RenderProfile } from './render/pipeline';
 export type { CacheStats } from './render/image-cache';
 export type { RenderMetrics } from './render/metrics';
+export { physicalDevice } from './adapter/physical-device';
+export type { StreamDeckAdapter, AdapterActionHandle, AdapterActionCallbacks, AdapterWillAppearEvent, AdapterActionDevice, AdapterController, AdapterCoordinates, AdapterSize, AdapterTriggerDescription, } from './adapter/types';
 export { useKeyDown, useKeyUp, useDialRotate, useDialDown, useDialUp, useTouchTap, useDialHint, } from './hooks/events';
 export { useTap, useLongPress, useDoubleTap } from './hooks/gestures';
 export { useSettings, useGlobalSettings } from './hooks/settings';
@@ -21,7 +23,9 @@ export { ProgressBar } from './components/ProgressBar';
 export { CircularGauge } from './components/CircularGauge';
 export { ErrorBoundary } from './components/ErrorBoundary';
 export { tw } from './tw/index';
-export type { PluginConfig, FontConfig, ActionConfig, ActionConfigInput, ActionDefinition, ActionUUID, ManifestActions, EncoderLayout, WrapperComponent, DeviceInfo, ActionInfo, CanvasInfo, TouchStripLayout, TouchStripLayoutItem, KeyDownPayload, KeyUpPayload, DialRotatePayload, DialPressPayload, TouchTapPayload, DialHints, StreamDeckAccess, TouchStripInfo, TouchStripTapPayload, TouchStripDialRotatePayload, TouchStripDialPressPayload, } from './types';
+export { googleFont } from './google-font';
+export type { GoogleFontVariant } from './google-font';
+export type { PluginConfig, Plugin, FontConfig, ActionConfig, ActionConfigInput, ActionDefinition, ActionUUID, ManifestActions, EncoderLayout, WrapperComponent, TakumiBackend, Controller, Coordinates, Size, DeviceInfo, ActionInfo, CanvasInfo, TouchStripLayout, TouchStripLayoutItem, KeyDownPayload, KeyUpPayload, DialRotatePayload, DialPressPayload, TouchTapPayload, DialHints, StreamDeckAccess, TouchStripInfo, TouchStripTapPayload, TouchStripDialRotatePayload, TouchStripDialPressPayload, } from './types';
 export type { TapOptions, LongPressOptions, DoubleTapOptions } from './hooks/gestures';
 export type { BoxProps } from './components/Box';
 export type { TextProps } from './components/Text';

package/dist/index.js

@@ -1,3 +1,4 @@
+import { physicalDevice } from "./adapter/physical-device.js";
 import { createPlugin } from "./plugin.js";
 import { defineAction } from "./action.js";
 import { useDialDown, useDialHint, useDialRotate, useDialUp, useKeyDown, useKeyUp, useTouchTap } from "./hooks/events.js";
@@ -17,4 +18,5 @@ import { ProgressBar } from "./components/ProgressBar.js";
 import { CircularGauge } from "./components/CircularGauge.js";
 import { ErrorBoundary } from "./components/ErrorBoundary.js";
 import { tw } from "./tw/index.js";
-export { Box, CircularGauge, Easings, ErrorBoundary, Icon, Image, ProgressBar, SpringPresets, Text, createPlugin, defineAction, tw, useAction, useCanvas, useDevice, useDialDown, useDialHint, useDialRotate, useDialUp, useDoubleTap, useGlobalSettings, useInterval, useKeyDown, useKeyUp, useLongPress, useOpenUrl, usePrevious, usePropertyInspector, useSendToPI, useSettings, useShowAlert, useShowOk, useSpring, useStreamDeck, useSwitchProfile, useTap, useTick, useTimeout, useTitle, useTouchStrip, useTouchStripDialDown, useTouchStripDialRotate, useTouchStripDialUp, useTouchStripTap, useTouchTap, useTween, useWillAppear, useWillDisappear };
+import { googleFont } from "./google-font.js";
+export { Box, CircularGauge, Easings, ErrorBoundary, Icon, Image, ProgressBar, SpringPresets, Text, createPlugin, defineAction, googleFont, physicalDevice, tw, useAction, useCanvas, useDevice, useDialDown, useDialHint, useDialRotate, useDialUp, useDoubleTap, useGlobalSettings, useInterval, useKeyDown, useKeyUp, useLongPress, useOpenUrl, usePrevious, usePropertyInspector, useSendToPI, useSettings, useShowAlert, useShowOk, useSpring, useStreamDeck, useSwitchProfile, useTap, useTick, useTimeout, useTitle, useTouchStrip, useTouchStripDialDown, useTouchStripDialRotate, useTouchStripDialUp, useTouchStripTap, useTouchTap, useTween, useWillAppear, useWillDisappear };

package/dist/plugin.js

@@ -2,57 +2,67 @@ import { metrics } from "./render/metrics.js";
 import { RootRegistry } from "./roots/registry.js";
 import { RenderPool } from "./render/render-pool.js";
 import { startDevtoolsServer } from "./devtools/index.js";
-import streamDeck, { SingletonAction } from "@elgato/streamdeck";
+import { physicalDevice } from "./adapter/physical-device.js";
 import { Renderer } from "@takumi-rs/core";
 //#region src/plugin.ts
 function createPlugin(config) {
-	const renderer = new Renderer({ fonts: config.fonts.map((f) => ({
+	const adapter = config.adapter ?? physicalDevice();
+	return { async connect() {
+		const takumiMode = config.takumi ?? "native-binding";
+		const renderPool = (takumiMode === "wasm" ? false : config.useWorker !== false) ? new RenderPool(config.fonts) : null;
+		const renderConfig = {
+			renderer: await initializeRenderer(takumiMode, config.fonts),
+			imageFormat: config.imageFormat ?? "png",
+			caching: config.caching ?? true,
+			devicePixelRatio: config.devicePixelRatio ?? 1,
+			debug: config.debug ?? process.env.NODE_ENV !== "production",
+			imageCacheMaxBytes: config.imageCacheMaxBytes ?? 16 * 1024 * 1024,
+			touchStripCacheMaxBytes: config.touchStripCacheMaxBytes ?? 8 * 1024 * 1024,
+			renderPool
+		};
+		const registry = new RootRegistry(renderConfig, adapter, async (settings) => {
+			await adapter.setGlobalSettings(settings);
+		}, config.wrapper);
+		adapter.getGlobalSettings().then((gs) => {
+			registry.setGlobalSettings(gs);
+		}).catch((err) => {
+			console.error("[@fcannizzaro/streamdeck-react] Failed to load global settings:", err);
+		});
+		adapter.onGlobalSettingsChanged((settings) => {
+			registry.setGlobalSettings(settings);
+		});
+		for (const definition of config.actions) registerActionWithAdapter(adapter, definition, registry, config.onActionError);
+		if (renderConfig.debug) metrics.enable();
+		if (config.devtools) startDevtoolsServer({
+			devtoolsName: adapter.pluginUUID,
+			registry,
+			renderConfig
+		});
+		if (renderPool != null) renderPool.initialize().catch(() => {});
+		await adapter.connect();
+	} };
+}
+async function initializeRenderer(mode, fonts) {
+	const fontData = fonts.map((f) => ({
 		name: f.name,
 		data: f.data,
 		weight: f.weight,
 		style: f.style
-	})) });
-	const renderPool = config.useWorker !== false ? new RenderPool(config.fonts) : null;
-	const renderConfig = {
-		renderer,
-		imageFormat: config.imageFormat ?? "png",
-		caching: config.caching ?? true,
-		devicePixelRatio: config.devicePixelRatio ?? 1,
-		debug: config.debug ?? process.env.NODE_ENV !== "production",
-		imageCacheMaxBytes: config.imageCacheMaxBytes ?? 16 * 1024 * 1024,
-		touchstripCacheMaxBytes: config.touchstripCacheMaxBytes ?? 8 * 1024 * 1024,
-		renderPool,
-		touchstripImageFormat: config.touchstripImageFormat ?? "webp"
-	};
-	const registry = new RootRegistry(renderConfig, config.renderDebounceMs ?? 16, streamDeck, async (settings) => {
-		await streamDeck.settings.setGlobalSettings(settings);
-	}, config.wrapper);
-	streamDeck.settings.getGlobalSettings().then((gs) => {
-		registry.setGlobalSettings(gs);
-	}).catch((err) => {
-		console.error("[@fcannizzaro/streamdeck-react] Failed to load global settings:", err);
-	});
-	streamDeck.settings.onDidReceiveGlobalSettings((ev) => {
-		registry.setGlobalSettings(ev.settings);
-	});
-	for (const definition of config.actions) {
-		const singletonAction = createSingletonAction(definition, registry, config.onActionError);
-		streamDeck.actions.registerAction(singletonAction);
+	}));
+	if (mode === "wasm") {
+		const wasm = await import("@takumi-rs/wasm");
+		await wasm.default();
+		return new wasm.Renderer({ fonts: fontData });
 	}
-	if (renderConfig.debug) metrics.enable();
-	if (config.devtools) startDevtoolsServer({
-		devtoolsName: streamDeck.info.plugin.uuid,
-		registry,
-		renderConfig
-	});
-	return { async connect() {
-		if (renderPool != null) renderPool.initialize().catch(() => {});
-		await streamDeck.connect();
-	} };
+	return new Renderer({ fonts: fontData });
 }
-function createSingletonAction(definition, registry, onError) {
-	return new class extends SingletonAction {
-		manifestId = definition.uuid;
+function registerActionWithAdapter(adapter, definition, registry, onError) {
+	const handleError = (actionId, err) => {
+		const error = err instanceof Error ? err : new Error(String(err));
+		console.error(`[@fcannizzaro/streamdeck-react] Error in action ${definition.uuid} (${actionId}):`, error);
+		onError?.(definition.uuid, actionId, error);
+	};
+	adapter.registerAction(definition.uuid, {
 		onWillAppear(ev) {
 			try {
 				const isEncoder = ev.payload.controller === "Encoder";
@@ -64,126 +74,94 @@ function createSingletonAction(definition, registry, onError) {
 				if (!component) return;
 				registry.create(ev, component, definition);
 			} catch (err) {
-				this.handleError(ev.action.id, err);
+				handleError(ev.action.id, err);
 			}
-		}
-		onWillDisappear(ev) {
+		},
+		onWillDisappear(actionId) {
 			try {
-				registry.destroy(ev.action.id);
+				registry.destroy(actionId);
 			} catch (err) {
-				this.handleError(ev.action.id, err);
+				handleError(actionId, err);
 			}
-		}
-		onKeyDown(ev) {
+		},
+		onKeyDown(actionId, payload) {
 			try {
-				registry.dispatch(ev.action.id, "keyDown", {
-					settings: ev.payload.settings,
-					isInMultiAction: ev.payload.isInMultiAction,
-					state: ev.payload.state,
-					userDesiredState: "userDesiredState" in ev.payload ? ev.payload.userDesiredState : void 0
-				});
+				registry.dispatch(actionId, "keyDown", payload);
 			} catch (err) {
-				this.handleError(ev.action.id, err);
+				handleError(actionId, err);
 			}
-		}
-		onKeyUp(ev) {
+		},
+		onKeyUp(actionId, payload) {
 			try {
-				registry.dispatch(ev.action.id, "keyUp", {
-					settings: ev.payload.settings,
-					isInMultiAction: ev.payload.isInMultiAction,
-					state: ev.payload.state,
-					userDesiredState: "userDesiredState" in ev.payload ? ev.payload.userDesiredState : void 0
-				});
+				registry.dispatch(actionId, "keyUp", payload);
 			} catch (err) {
-				this.handleError(ev.action.id, err);
+				handleError(actionId, err);
 			}
-		}
-		onDialRotate(ev) {
+		},
+		onDialRotate(actionId, payload) {
 			try {
-				registry.dispatch(ev.action.id, "dialRotate", {
-					ticks: ev.payload.ticks,
-					pressed: ev.payload.pressed,
-					settings: ev.payload.settings
-				});
+				registry.dispatch(actionId, "dialRotate", payload);
 			} catch (err) {
-				this.handleError(ev.action.id, err);
+				handleError(actionId, err);
 			}
-		}
-		onDialDown(ev) {
+		},
+		onDialDown(actionId, payload) {
 			try {
-				registry.dispatch(ev.action.id, "dialDown", {
-					settings: ev.payload.settings,
-					controller: "Encoder"
-				});
+				registry.dispatch(actionId, "dialDown", payload);
 			} catch (err) {
-				this.handleError(ev.action.id, err);
+				handleError(actionId, err);
 			}
-		}
-		onDialUp(ev) {
+		},
+		onDialUp(actionId, payload) {
 			try {
-				registry.dispatch(ev.action.id, "dialUp", {
-					settings: ev.payload.settings,
-					controller: "Encoder"
-				});
+				registry.dispatch(actionId, "dialUp", payload);
 			} catch (err) {
-				this.handleError(ev.action.id, err);
+				handleError(actionId, err);
 			}
-		}
-		onTouchTap(ev) {
+		},
+		onTouchTap(actionId, payload) {
 			try {
-				registry.dispatch(ev.action.id, "touchTap", {
-					tapPos: ev.payload.tapPos,
-					hold: ev.payload.hold,
-					settings: ev.payload.settings
-				});
+				registry.dispatch(actionId, "touchTap", payload);
 			} catch (err) {
-				this.handleError(ev.action.id, err);
+				handleError(actionId, err);
 			}
-		}
-		onDidReceiveSettings(ev) {
+		},
+		onDidReceiveSettings(actionId, settings) {
 			try {
-				registry.updateSettings(ev.action.id, ev.payload.settings);
+				registry.updateSettings(actionId, settings);
 			} catch (err) {
-				this.handleError(ev.action.id, err);
+				handleError(actionId, err);
 			}
-		}
-		onSendToPlugin(ev) {
+		},
+		onSendToPlugin(actionId, payload) {
 			try {
-				registry.dispatch(ev.action.id, "sendToPlugin", ev.payload);
+				registry.dispatch(actionId, "sendToPlugin", payload);
 			} catch (err) {
-				this.handleError(ev.action.id, err);
+				handleError(actionId, err);
 			}
-		}
-		onPropertyInspectorDidAppear(ev) {
+		},
+		onPropertyInspectorDidAppear(actionId) {
 			try {
-				registry.dispatch(ev.action.id, "propertyInspectorDidAppear", void 0);
+				registry.dispatch(actionId, "propertyInspectorDidAppear", void 0);
 			} catch (err) {
-				this.handleError(ev.action.id, err);
+				handleError(actionId, err);
 			}
-		}
-		onPropertyInspectorDidDisappear(ev) {
+		},
+		onPropertyInspectorDidDisappear(actionId) {
 			try {
-				registry.dispatch(ev.action.id, "propertyInspectorDidDisappear", void 0);
+				registry.dispatch(actionId, "propertyInspectorDidDisappear", void 0);
 			} catch (err) {
-				this.handleError(ev.action.id, err);
+				handleError(actionId, err);
 			}
-		}
-		onTitleParametersDidChange(ev) {
+		},
+		onTitleParametersDidChange(actionId, payload) {
 			try {
-				registry.dispatch(ev.action.id, "titleParametersDidChange", {
-					title: ev.payload.title,
-					settings: ev.payload.settings
-				});
+				registry.dispatch(actionId, "titleParametersDidChange", payload);
 			} catch (err) {
-				this.handleError(ev.action.id, err);
+				handleError(actionId, err);
 			}
 		}
-		handleError(actionId, err) {
-			const error = err instanceof Error ? err : new Error(String(err));
-			console.error(`[@fcannizzaro/streamdeck-react] Error in action ${definition.uuid} (${actionId}):`, error);
-			onError?.(definition.uuid, actionId, error);
-		}
-	}();
+	});
 }
 //#endregion
 export { createPlugin };

package/dist/reconciler/vnode.d.ts

@@ -1,4 +1,3 @@
-import { ReactElement } from 'react';
 export interface VNode {
     type: string;
     props: Record<string, unknown>;
@@ -41,4 +40,3 @@ export declare function clearParent(child: VNode): void;
 export declare function createVNode(type: string, props: Record<string, unknown>): VNode;
 export declare function createTextVNode(text: string): VNode;
 export declare function createVContainer(renderCallback: () => void): VContainer;
-export declare function vnodeToElement(node: VNode): ReactElement | string;

package/dist/reconciler/vnode.js

@@ -1,4 +1,3 @@
-import "react";
 //#region src/reconciler/vnode.ts
 /** Mark a node (and its ancestors up to the container) as dirty. */
 function markDirty(node) {

package/dist/render/cache.d.ts

@@ -1,24 +1,12 @@
 import { VNode, VContainer } from '../reconciler/vnode';
-/**
- * Initialize the xxHash-wasm module.  Call is idempotent — subsequent
- * calls return the same promise.  Resolves once `fnv1a()` will use the
- * WASM fast path for large buffers.
- */
-export declare function initBufferHasher(): Promise<void>;
-/** Reset the xxHash singleton — for testing only. */
-export declare function resetBufferHasher(): void;
 /**
  * Hash a raw byte buffer (Uint8Array or Buffer) or string.
  *
- * For buffers larger than {@link STRIDE_THRESHOLD} bytes:
- * - **Primary path**: xxHash-wasm `h32Raw()` — hashes the entire buffer
- *   in native WASM code.  Faster than JS strided sampling even for
- *   320 KB touchstrip frames, with superior hash distribution.
- * - **Fallback path**: FNV-1a with strided sampling (every 16th byte)
- *   when WASM hasn't compiled yet (startup) or is unavailable.
+ * For buffers larger than {@link STRIDE_THRESHOLD} bytes, uses strided
+ * FNV-1a sampling (every 16th byte) — at 30fps this adds <1ms even
+ * for 320KB TouchStrip buffers.
  *
- * Strings and small buffers always use JS FNV-1a (fast enough at those
- * sizes, and avoids the overhead of calling into WASM for tiny inputs).
+ * Strings and small buffers always use full byte-by-byte FNV-1a.
  */
 export declare function fnv1a(input: string | Uint8Array | Buffer): number;
 /** Feed a string into a running FNV-1a hash. */
@@ -39,4 +27,4 @@ export declare function computeHash(node: VNode): number;
  */
 export declare function computeTreeHash(container: VContainer): number;
 export declare function computeCacheKey(treeHash: number, width: number, height: number, dpr: number, format: string): number;
-export declare function computeNativeTouchstripCacheKey(treeHash: number, width: number, height: number, dpr: number, format: string, columns: number[]): number;
+export declare function computeTouchStripSegmentCacheKey(treeHash: number, width: number, height: number, dpr: number, columns: number[]): number;