@fcannizzaro/streamdeck-react 0.1.12 → 0.1.14

package/dist/manifest-gen.js

@@ -0,0 +1,229 @@
+import { dirname } from "node:path";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+//#region src/manifest-gen.ts
+/**
+* Validate just the plugin UUID format.
+*
+* Used in `buildStart` for early error reporting before action
+* extraction is complete.
+*
+* @returns A validation error if the UUID is invalid, or `null` if valid.
+*/
+function validatePluginUUID(uuid) {
+	if (!/^([a-z0-9-]+)(\.[a-z0-9-]+)+$/.test(uuid)) return {
+		field: "uuid",
+		message: `Plugin UUID "${uuid}" must be in reverse-DNS format (lowercase alphanumeric, hyphens, periods)`
+	};
+	return null;
+}
+/**
+* Validate a full ManifestConfig for correctness.
+*
+* Checks:
+*   - All action UUIDs are prefixed with the plugin UUID
+*   - No duplicate action UUIDs
+*   - Plugin UUID matches reverse-DNS pattern
+*
+* Called in `writeBundle` after action extraction is complete.
+*/
+function validateManifestConfig(config, warn) {
+	const errors = [];
+	const uuidError = validatePluginUUID(config.uuid);
+	if (uuidError) errors.push(uuidError);
+	const prefix = config.uuid + ".";
+	const seenUuids = /* @__PURE__ */ new Set();
+	for (const action of config.actions) {
+		if (!action.uuid.startsWith(prefix)) {
+			const error = {
+				field: `actions[${action.uuid}].uuid`,
+				message: `Action UUID "${action.uuid}" must be prefixed with plugin UUID "${config.uuid}."`
+			};
+			errors.push(error);
+			warn?.(`[@fcannizzaro/streamdeck-react] ${error.message}`);
+		}
+		if (seenUuids.has(action.uuid)) errors.push({
+			field: `actions[${action.uuid}].uuid`,
+			message: `Duplicate action UUID "${action.uuid}"`
+		});
+		seenUuids.add(action.uuid);
+	}
+	return errors;
+}
+/** Add a key to the record only if the value is defined. */
+function addIf(record, key, value) {
+	if (value !== void 0 && value !== null) record[key] = value;
+}
+function buildTriggerDescription(td) {
+	const out = {};
+	addIf(out, "Rotate", td.rotate);
+	addIf(out, "Push", td.push);
+	addIf(out, "Touch", td.touch);
+	addIf(out, "LongTouch", td.longTouch);
+	return out;
+}
+function buildEncoder(encoder) {
+	const out = {};
+	addIf(out, "layout", encoder.layout);
+	addIf(out, "Icon", encoder.icon);
+	addIf(out, "StackColor", encoder.stackColor);
+	addIf(out, "background", encoder.background);
+	if (encoder.triggerDescription) out["TriggerDescription"] = buildTriggerDescription(encoder.triggerDescription);
+	return out;
+}
+function buildState(state) {
+	const out = { Image: state.image };
+	addIf(out, "Name", state.name);
+	addIf(out, "Title", state.title);
+	addIf(out, "ShowTitle", state.showTitle);
+	addIf(out, "TitleAlignment", state.titleAlignment);
+	addIf(out, "TitleColor", state.titleColor);
+	addIf(out, "FontFamily", state.fontFamily);
+	addIf(out, "FontSize", state.fontSize);
+	addIf(out, "FontStyle", state.fontStyle);
+	addIf(out, "FontUnderline", state.fontUnderline);
+	addIf(out, "MultiActionImage", state.multiActionImage);
+	return out;
+}
+/**
+* Derive Controllers from an action definition.
+*
+* Priority:
+*   1. Explicit `controllers` on info → use as-is
+*   2. Derived from key/dial/touchStrip presence:
+*      - key → includes "Keypad"
+*      - dial or touchStrip → includes "Encoder"
+*      - both → ["Keypad", "Encoder"]
+*   3. Default → ["Keypad"]
+*/
+function deriveControllers(action) {
+	const info = action.info;
+	if (info?.controllers) return info.controllers.filter((c) => c != null);
+	const hasKey = action.key != null;
+	const hasEncoder = action.dial != null || action.touchStrip != null;
+	if (hasKey && hasEncoder) return ["Keypad", "Encoder"];
+	if (hasEncoder) return ["Encoder"];
+	if (hasKey) return ["Keypad"];
+	if (info?.encoder) return ["Encoder"];
+	return ["Keypad"];
+}
+function buildAction(action) {
+	const info = action.info;
+	if (!info) throw new Error(`[@fcannizzaro/streamdeck-react] Action "${action.uuid}" is missing \`info\`. Add info: { name, icon } to the defineAction() call.`);
+	const controllers = deriveControllers(action);
+	const states = info.states ? info.states.map(buildState) : [{ Image: info.icon }];
+	const out = {
+		UUID: action.uuid,
+		Name: info.name,
+		Icon: info.icon,
+		Controllers: controllers,
+		States: states
+	};
+	addIf(out, "Tooltip", info.tooltip);
+	addIf(out, "DisableAutomaticStates", info.disableAutomaticStates);
+	addIf(out, "DisableCaching", info.disableCaching);
+	addIf(out, "SupportedInMultiActions", info.supportedInMultiActions);
+	addIf(out, "SupportedInKeyLogicActions", info.supportedInKeyLogicActions);
+	addIf(out, "VisibleInActionsList", info.visibleInActionsList);
+	addIf(out, "UserTitleEnabled", info.userTitleEnabled);
+	addIf(out, "PropertyInspectorPath", info.propertyInspectorPath);
+	addIf(out, "SupportURL", info.supportUrl);
+	if (info.encoder) out["Encoder"] = buildEncoder(info.encoder);
+	if (info.os) out["OS"] = info.os;
+	return out;
+}
+var DEFAULT_OS = [{
+	platform: "mac",
+	minimumVersion: "13"
+}, {
+	platform: "windows",
+	minimumVersion: "10"
+}];
+function buildOS(osEntries) {
+	return osEntries.filter((o) => o != null).map((o) => ({
+		Platform: o.platform,
+		MinimumVersion: o.minimumVersion
+	}));
+}
+function buildNodejs(nodejs) {
+	const out = { Version: nodejs.version };
+	addIf(out, "Debug", nodejs.debug);
+	addIf(out, "GenerateProfilerOutput", nodejs.generateProfilerOutput);
+	return out;
+}
+function buildProfile(profile) {
+	const out = {
+		Name: profile.name,
+		DeviceType: profile.deviceType
+	};
+	addIf(out, "AutoInstall", profile.autoInstall);
+	addIf(out, "DontAutoSwitchWhenInstalled", profile.dontAutoSwitchWhenInstalled);
+	addIf(out, "Readonly", profile.readonly);
+	return out;
+}
+/**
+* Build the full manifest JSON object from a ManifestConfig.
+*
+* Applies all auto-derivation defaults and transforms camelCase
+* to the PascalCase format expected by the Elgato schema.
+*
+* @param config - The manifest configuration
+* @param codePath - Override CodePath (typically derived from bundler output)
+*/
+function buildManifestJson(config, codePath) {
+	const osEntries = config.os ? config.os.filter((o) => o != null) : DEFAULT_OS;
+	const nodejs = config.nodejs ?? { version: "24" };
+	const out = {
+		$schema: "https://schemas.elgato.com/streamdeck/plugins/manifest.json",
+		UUID: config.uuid,
+		Name: config.name,
+		Author: config.author,
+		Description: config.description,
+		Icon: config.icon,
+		Version: config.version,
+		CodePath: codePath ?? config.codePath ?? "bin/plugin.mjs",
+		OS: buildOS(osEntries),
+		Nodejs: buildNodejs(nodejs),
+		SDKVersion: config.sdkVersion ?? 2,
+		Software: { MinimumVersion: config.software?.minimumVersion ?? "7.1" },
+		Category: config.category ?? config.name,
+		CategoryIcon: config.categoryIcon ?? config.icon,
+		Actions: config.actions.map(buildAction)
+	};
+	addIf(out, "URL", config.url);
+	addIf(out, "SupportURL", config.supportUrl);
+	addIf(out, "PropertyInspectorPath", config.propertyInspectorPath);
+	addIf(out, "DefaultWindowSize", config.defaultWindowSize);
+	addIf(out, "CodePathMac", config.codePathMac);
+	addIf(out, "CodePathWin", config.codePathWin);
+	if (config.applicationsToMonitor) out["ApplicationsToMonitor"] = config.applicationsToMonitor;
+	if (config.profiles?.length) out["Profiles"] = config.profiles.map(buildProfile);
+	return out;
+}
+/**
+* Generate the full manifest JSON string from a ManifestConfig.
+*
+* @param config - The manifest configuration
+* @param codePath - Override CodePath (typically derived from bundler output)
+* @returns Formatted JSON string
+*/
+function generateManifestJsonString(config, codePath) {
+	const json = buildManifestJson(config, codePath);
+	return JSON.stringify(json, null, 2) + "\n";
+}
+/**
+* Write manifest.json only when the content has changed.
+* Creates the parent directory if it does not exist.
+*
+* @returns `true` if the file was written, `false` if content was unchanged.
+*/
+function writeManifestIfChanged(outPath, content) {
+	if (existsSync(outPath)) {
+		if (readFileSync(outPath, "utf-8") === content) return false;
+	}
+	const dir = dirname(outPath);
+	if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+	writeFileSync(outPath, content);
+	return true;
+}
+//#endregion
+export { generateManifestJsonString, validateManifestConfig, validatePluginUUID, writeManifestIfChanged };

package/dist/manifest-types.d.ts

@@ -0,0 +1,238 @@
+export type ManifestController = "Encoder" | "Keypad";
+export interface ManifestOSInfo {
+    platform: "mac" | "windows";
+    minimumVersion: string;
+}
+export interface ManifestNodejsInfo {
+    /**
+     * Node.js version to use.
+     * @default "24"
+     */
+    version: "20" | "24";
+    /**
+     * Debug configuration.  `"enabled"` and `"break"` are shortcuts for
+     * `--inspect` and `--inspect-brk` respectively.  A custom string is
+     * passed as-is (e.g. `"--inspect=127.0.0.1:8090"`).
+     */
+    debug?: string;
+    /** Enable profiler output. */
+    generateProfilerOutput?: boolean;
+}
+export interface ManifestStateInfo {
+    /** Path to state image (extension omitted). 72×72 and 144×144 @2x. */
+    image: string;
+    /** State name (shown in multi-action state selector). */
+    name?: string;
+    /** Default title text. */
+    title?: string;
+    /** Whether to show the title. */
+    showTitle?: boolean;
+    /** Title alignment. */
+    titleAlignment?: "bottom" | "middle" | "top";
+    /** Title color (hex). */
+    titleColor?: string;
+    /** Font family for the title. */
+    fontFamily?: string;
+    /** Font size for the title. */
+    fontSize?: number;
+    /** Font style for the title. */
+    fontStyle?: "" | "Bold" | "Bold Italic" | "Italic" | "Regular";
+    /** Whether the title is underlined. */
+    fontUnderline?: boolean;
+    /** Image shown when the action is in a multi-action. */
+    multiActionImage?: string;
+}
+export interface ManifestTriggerDescription {
+    /** Dial rotation description. */
+    rotate?: string;
+    /** Dial press description. */
+    push?: string;
+    /** Touch tap description. */
+    touch?: string;
+    /** Long touch description. */
+    longTouch?: string;
+}
+export interface ManifestEncoderInfo {
+    /**
+     * Touch screen layout.  Pre-defined: `$X1`, `$A0`, `$A1`, `$B1`,
+     * `$B2`, `$C1`.  Or a path to a custom `.json` layout file.
+     */
+    layout?: string;
+    /** Encoder icon (extension omitted). 72×72 and 144×144 @2x. */
+    icon?: string;
+    /** Background color for dial stack (hex). */
+    stackColor?: string;
+    /** Touchscreen background image (extension omitted). 200×100 and 400×200 @2x. */
+    background?: string;
+    /** Descriptions shown to the user for each interaction type. */
+    triggerDescription?: ManifestTriggerDescription;
+}
+export interface ManifestProfileInfo {
+    /** Path to .streamDeckProfile file (extension omitted). */
+    name: string;
+    /**
+     * Target device type.
+     *
+     * Common values:
+     *   0 = Stream Deck, 1 = Mini, 2 = XL, 5 = Pedal,
+     *   7 = Stream Deck +, 9 = Neo, 10 = Studio
+     */
+    deviceType: number;
+    /** Auto-install when plugin is installed. @default true */
+    autoInstall?: boolean;
+    /** Don't auto-switch to profile on first install. @default false */
+    dontAutoSwitchWhenInstalled?: boolean;
+    /** Profile is read-only. @default false */
+    readonly?: boolean;
+}
+export interface ActionManifestInfo {
+    /** Action display name in Stream Deck's action list. */
+    name: string;
+    /** Path to action icon (extension omitted). 20×20 and 40×40 @2x. */
+    icon: string;
+    /**
+     * Skip this action during auto-extraction for manifest generation.
+     * The action is still registered at runtime but excluded from the
+     * generated manifest.json.
+     *
+     * @default false
+     */
+    disabled?: boolean;
+    /** Hover tooltip in the actions list. */
+    tooltip?: string;
+    /**
+     * Custom states.  When omitted, a single state is generated
+     * using the `icon` field as the state image.
+     * @default [{ image: icon }]
+     */
+    states?: ManifestStateInfo[];
+    /** Encoder config (layout, triggerDescription, background). */
+    encoder?: ManifestEncoderInfo;
+    /** Disable automatic state toggling. @default false */
+    disableAutomaticStates?: boolean;
+    /** Disable Stream Deck image caching. @default false */
+    disableCaching?: boolean;
+    /** Available in multi-actions. @default true */
+    supportedInMultiActions?: boolean;
+    /** Available in key logic actions (SD 7.0+). @default true */
+    supportedInKeyLogicActions?: boolean;
+    /** Visible in the actions list. @default true */
+    visibleInActionsList?: boolean;
+    /** Allow user to edit title. @default true */
+    userTitleEnabled?: boolean;
+    /** Action-specific property inspector HTML path. */
+    propertyInspectorPath?: string;
+    /** Action support URL. */
+    supportUrl?: string;
+    /** OS restriction for this action. */
+    os?: ("mac" | "windows")[];
+    /**
+     * Controller types.
+     *
+     * Auto-derived in bundler plugin:
+     *   - `encoder` field present → `["Encoder"]`
+     *   - otherwise → `["Keypad"]`
+     *
+     * @default ["Keypad"]
+     */
+    controllers?: [ManifestController, ManifestController?];
+}
+export interface ManifestActionSource {
+    uuid: string;
+    /** Presence indicates Keypad controller support. */
+    key?: unknown;
+    /** Presence indicates Encoder controller support. */
+    dial?: unknown;
+    /** Presence indicates Encoder controller support (touchstrip variant). */
+    touchStrip?: unknown;
+    /** Action manifest metadata. Required for manifest generation. */
+    info?: ActionManifestInfo;
+}
+export interface ManifestConfig extends PluginManifestInfo {
+    /**
+     * Action definitions from defineAction().
+     * Each action must have `info` populated with at least `name` and `icon`.
+     * Controllers are auto-derived from key/dial/touchStrip presence.
+     */
+    actions: ManifestActionSource[];
+}
+export interface PluginManifestInfo {
+    /**
+     * Unique plugin identifier in reverse-DNS format.
+     *
+     * All action UUIDs must be prefixed with this value.
+     */
+    uuid: string;
+    /** Plugin display name. */
+    name: string;
+    /** Author name shown on Marketplace. */
+    author: string;
+    /** Plugin description. */
+    description: string;
+    /** Path to plugin icon (extension omitted). 256×256 and 512×512 @2x. */
+    icon: string;
+    /**
+     * Plugin version.
+     * @example "1.0.0.0"
+     */
+    version: string;
+    /**
+     * Actions list group name.
+     * @default Same as `name`
+     */
+    category?: string;
+    /**
+     * Category icon path (extension omitted).
+     * @default Same as `icon`
+     */
+    categoryIcon?: string;
+    /** Plugin website URL. */
+    url?: string;
+    /** Support website URL. */
+    supportUrl?: string;
+    /** Global property inspector HTML path. */
+    propertyInspectorPath?: string;
+    /** Pre-defined profiles distributed with the plugin. */
+    profiles?: ManifestProfileInfo[];
+    /** Applications to monitor on Mac/Windows. */
+    applicationsToMonitor?: {
+        mac?: string[];
+        windows?: string[];
+    };
+    /**
+     * Default window size for `window.open()` from the property inspector.
+     * @example [500, 650]
+     */
+    defaultWindowSize?: [number, number];
+    /** macOS-specific entry point override. */
+    codePathMac?: string;
+    /** Windows-specific entry point override. */
+    codePathWin?: string;
+    /**
+     * Plugin entry point path.
+     * @default Derived from bundler output path (e.g. "bin/plugin.mjs")
+     */
+    codePath?: string;
+    /**
+     * Operating system requirements.
+     * @default [{ platform: "mac", minimumVersion: "13" }, { platform: "windows", minimumVersion: "10" }]
+     */
+    os?: [ManifestOSInfo, ManifestOSInfo?];
+    /**
+     * Node.js configuration.
+     * @default { version: "24" }
+     */
+    nodejs?: ManifestNodejsInfo;
+    /**
+     * SDK version.
+     * @default 2
+     */
+    sdkVersion?: 2 | 3;
+    /**
+     * Stream Deck software requirements.
+     * @default { minimumVersion: "7.1" }
+     */
+    software?: {
+        minimumVersion: string;
+    };
+}

package/dist/plugin.js

@@ -7,46 +7,55 @@ import { Renderer } from "@takumi-rs/core";
 //#region src/plugin.ts
 function createPlugin(config) {
 	const adapter = config.adapter ?? physicalDevice();
-	const renderer = new Renderer({ fonts: config.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
-	};
-	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
-	});
 	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
+	}));
+	if (mode === "wasm") {
+		const wasm = await import("@takumi-rs/wasm");
+		await wasm.default();
+		return new wasm.Renderer({ fonts: fontData });
+	}
+	return new Renderer({ fonts: fontData });
+}
 function registerActionWithAdapter(adapter, definition, registry, onError) {
 	const handleError = (actionId, err) => {
 		const error = err instanceof Error ? err : new Error(String(err));

package/dist/render/render-pool.js

@@ -36,7 +36,7 @@ var RenderPool = class {
 	}
 	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) => ({
+			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
        // Cast: TakumiNode is a local structural duplicate of the
        // @takumi-rs/helpers Node union — the shapes match at runtime
        // but TypeScript can't verify the discriminated union members
        // from the loose `type: string` index signature.
        const buffer = await renderer.render(
          rootNode as unknown as import("@takumi-rs/helpers").Node,
          {
            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,