@fcannizzaro/streamdeck-react 0.1.12 → 0.1.14

package/README.md

@@ -63,11 +63,13 @@ export const counterAction = defineAction({
 Register it in your plugin entrypoint:
 
 ```ts
-import { createPlugin } from "@fcannizzaro/streamdeck-react";
+import { createPlugin, googleFont } from "@fcannizzaro/streamdeck-react";
 import { counterAction } from "./actions/counter.tsx";
 
+const inter = await googleFont("Inter");
+
 const plugin = createPlugin({
-  fonts: [],
+  fonts: [inter],
   actions: [counterAction],
 });
 
@@ -83,12 +85,13 @@ await plugin.connect();
 
 ## Samples
 
-- `samples/counter/` - local state, settings hook, dial interaction
-- `samples/zustand/` - shared external store across multiple actions
-- `samples/jotai/` - shared atom state with a plugin-level wrapper
-- `samples/pokemon/` - richer plugin example with custom wrappers
-- `samples/snake/` - snake game on the Stream Deck+ touch strip using dial controls and touch tap
-- `samples/weather/` - weather forecast dials with animated detail panels and a shared Zustand store
+- `samples/counter/` — local state, persisted settings, dial interaction
+- `samples/zustand/` — shared state across keys via a module-scope Zustand store
+- `samples/jotai/` — shared atom state with a plugin-level Jotai Provider wrapper
+- `samples/pokemon/` — data fetching with TanStack Query and remote image rendering
+- `samples/animation/` — spring bounce, fade-slide, and spring dial animations
+- `samples/snake/` — snake game on the Stream Deck+ TouchStrip using dial controls and touch tap
+- `samples/weather/` — weather forecast dials with animated detail panels and a shared Zustand store
 
 ## DevTools
 

package/dist/action.d.ts

@@ -1,3 +1,3 @@
-import { ActionConfigInput, ActionDefinition } from './types';
+import { ActionConfig, ActionDefinition } from './types';
 import { JsonObject } from '@elgato/utils';
-export declare function defineAction<S extends JsonObject = JsonObject>(config: ActionConfigInput<S>): ActionDefinition<S>;
+export declare function defineAction<S extends JsonObject = JsonObject>(config: ActionConfig<S>): ActionDefinition<S>;

package/dist/action.js

@@ -7,7 +7,8 @@ function defineAction(config) {
 		touchStrip: config.touchStrip,
 		dialLayout: config.dialLayout,
 		wrapper: config.wrapper,
-		defaultSettings: config.defaultSettings ?? {}
+		defaultSettings: config.defaultSettings ?? {},
+		info: config.info
 	};
 }
 //#endregion

package/dist/bundler-shared.d.ts

@@ -4,8 +4,16 @@ export interface StreamDeckTarget {
     platform: StreamDeckPlatform;
     arch: StreamDeckArch;
 }
+/** Takumi renderer backend selection. Mirrors the runtime `TakumiBackend` type for build-time configuration. */
+export type TakumiBackend = "native-binding" | "wasm";
 export interface StreamDeckTargetOptions {
     targets?: StreamDeckTarget[];
+    /**
+     * Takumi renderer backend. When `"wasm"`, native `.node` binding
+     * copying is skipped entirely during the build.
+     * @default "native-binding"
+     */
+    takumi?: TakumiBackend;
 }
 export interface ResolvedTarget extends StreamDeckTarget {
     pkg: string;
@@ -17,6 +25,8 @@ export declare function isArch(value: string): value is StreamDeckArch;
 export declare function isDevelopmentMode(watchMode: boolean | undefined): boolean;
 export declare const NOOP_DEVTOOLS_ID = "\0streamdeck-react:noop-devtools";
 export declare const NOOP_DEVTOOLS_CODE = "export function startDevtoolsServer() {}";
+export declare const TAKUMI_NATIVE_LOADER_ID = "\0streamdeck-react:takumi-native";
+export declare const TAKUMI_NATIVE_LOADER_CODE: string;
 /**
  * Returns true when devtools should be stripped from the bundle.
  * Only strips in explicit production mode (NODE_ENV=production) to avoid
@@ -43,3 +53,24 @@ export declare function expandTargets(targets: StreamDeckTarget[]): ResolvedTarg
  * In production: missing bindings throw an error (the plugin won't work).
  */
 export declare function copyNativeBindings(outDir: string, isDevelopment: boolean, options: StreamDeckTargetOptions, warn: (message: string) => void): void;
+/**
+ * Resolve the .sdPlugin directory root from the bundler output directory.
+ *
+ * Strategy:
+ *   1. Walk up from outDir looking for a parent named `*.sdPlugin`
+ *   2. If not found, assume outDir's parent is the .sdPlugin root
+ *      (handles `<uuid>.sdPlugin/bin/` → `<uuid>.sdPlugin/`)
+ *
+ * @returns The .sdPlugin directory path, or `null` if unresolvable.
+ */
+export declare function resolvePluginDir(outDir: string): string | null;
+/**
+ * Derive the CodePath (manifest entry point) from the bundler output
+ * file path, relative to the .sdPlugin directory.
+ *
+ * Example:
+ *   outFile: "/project/com.example.sdPlugin/bin/plugin.mjs"
+ *   pluginDir: "/project/com.example.sdPlugin"
+ *   → "bin/plugin.mjs"
+ */
+export declare function deriveCodePath(outFile: string, pluginDir: string): string;

package/dist/bundler-shared.js

@@ -1,4 +1,4 @@
-import { dirname, join } from "node:path";
+import { dirname, join, relative } from "node:path";
 import { createRequire } from "node:module";
 import { copyFileSync, existsSync } from "node:fs";
 //#region src/bundler-shared.ts
@@ -40,6 +40,32 @@ function isDevelopmentMode(watchMode) {
 var NOOP_DEVTOOLS_ID = "\0streamdeck-react:noop-devtools";
 var NOOP_DEVTOOLS_CODE = "export function startDevtoolsServer() {}";
 var DEVTOOLS_IMPORT_SOURCE = "./devtools/index.js";
+var TAKUMI_NATIVE_LOADER_ID = "\0streamdeck-react:takumi-native";
+var TAKUMI_NATIVE_LOADER_CODE = `
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+let binding = null;
+if (process.platform === "darwin") {
+  if (process.arch === "arm64") {
+    try { binding = require("./core.darwin-arm64.node"); } catch {}
+  } else if (process.arch === "x64") {
+    try { binding = require("./core.darwin-x64.node"); } catch {}
+  }
+} else if (process.platform === "win32") {
+  if (process.arch === "arm64") {
+    try { binding = require("./core.win32-arm64-msvc.node"); } catch {}
+  } else if (process.arch === "x64") {
+    try { binding = require("./core.win32-x64-msvc.node"); } catch {}
+  }
+}
+if (!binding) {
+  throw new Error(
+    "[@fcannizzaro/streamdeck-react] Failed to load @takumi-rs/core native binding for " +
+    process.platform + "-" + process.arch
+  );
+}
+export const { Renderer, OutputFormat, DitheringAlgorithm, AnimationOutputFormat, extractResourceUrls } = binding;
+`.trim();
 /**
 * Returns true when devtools should be stripped from the bundle.
 * Only strips in explicit production mode (NODE_ENV=production) to avoid
@@ -92,6 +118,7 @@ function expandTargets(targets) {
 * In production: missing bindings throw an error (the plugin won't work).
 */
 function copyNativeBindings(outDir, isDevelopment, options, warn) {
+	if (options.takumi === "wasm") return;
 	try {
 		const requestedTargets = normalizeTargetRequests(options, isDevelopment);
 		if (requestedTargets.length === 0) {
@@ -128,5 +155,40 @@ function copyNativeBindings(outDir, isDevelopment, options, warn) {
 		throw new Error(`[@fcannizzaro/streamdeck-react] Failed to copy native binding: ${String(err)}`);
 	}
 }
+/**
+* Resolve the .sdPlugin directory root from the bundler output directory.
+*
+* Strategy:
+*   1. Walk up from outDir looking for a parent named `*.sdPlugin`
+*   2. If not found, assume outDir's parent is the .sdPlugin root
+*      (handles `<uuid>.sdPlugin/bin/` → `<uuid>.sdPlugin/`)
+*
+* @returns The .sdPlugin directory path, or `null` if unresolvable.
+*/
+function resolvePluginDir(outDir) {
+	let dir = outDir;
+	const root = dirname(dir);
+	for (let i = 0; i < 4; i++) {
+		if (dir.endsWith(".sdPlugin")) return dir;
+		const parent = dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+	const parent = dirname(outDir);
+	if (parent !== root && parent.endsWith(".sdPlugin")) return parent;
+	return null;
+}
+/**
+* Derive the CodePath (manifest entry point) from the bundler output
+* file path, relative to the .sdPlugin directory.
+*
+* Example:
+*   outFile: "/project/com.example.sdPlugin/bin/plugin.mjs"
+*   pluginDir: "/project/com.example.sdPlugin"
+*   → "bin/plugin.mjs"
+*/
+function deriveCodePath(outFile, pluginDir) {
+	return relative(pluginDir, outFile).replace(/\\/g, "/");
+}
 //#endregion
-export { NOOP_DEVTOOLS_CODE, NOOP_DEVTOOLS_ID, copyNativeBindings, isDevelopmentMode, isLibraryDevtoolsImport, shouldStripDevtools };
+export { NOOP_DEVTOOLS_CODE, NOOP_DEVTOOLS_ID, TAKUMI_NATIVE_LOADER_CODE, TAKUMI_NATIVE_LOADER_ID, copyNativeBindings, deriveCodePath, isDevelopmentMode, isLibraryDevtoolsImport, resolvePluginDir, shouldStripDevtools };

package/dist/font-inline.js

@@ -1,7 +1,7 @@
+import { readFile } from "node:fs/promises";
 import { dirname, resolve } from "node:path";
 import { createRequire } from "node:module";
 import { realpathSync } from "node:fs";
-import { readFile } from "node:fs/promises";
 //#region src/font-inline.ts
 var FONT_RE = /\.(ttf|otf|woff2?)$/;
 /**

package/dist/google-font.d.ts

@@ -0,0 +1,61 @@
+import { FontConfig } from './types';
+type FontWeight = FontConfig["weight"];
+type FontStyle = FontConfig["style"];
+export interface GoogleFontVariant {
+    weight?: FontWeight;
+    style?: FontStyle;
+}
+/**
+ * Fetch a Google Font as a ready-to-use `FontConfig`.
+ *
+ * Downloads TTF font data directly from Google Fonts — no npm package
+ * needed. The returned config can be passed straight into
+ * `createPlugin({ fonts: [...] })`.
+ *
+ * Font files are cached to `.google-fonts/` in the current working
+ * directory. Subsequent calls read from disk without network access.
+ *
+ * @param family - The Google Font family name (e.g. `"Inter"`, `"Roboto"`).
+ * @returns A `FontConfig` with weight 400 and normal style.
+ *
+ * @example
+ * ```ts
+ * const inter = await googleFont("Inter");
+ * createPlugin({ fonts: [inter], actions: [...] });
+ * ```
+ */
+export declare function googleFont(family: string): Promise<FontConfig>;
+/**
+ * Fetch a specific weight/style variant of a Google Font.
+ *
+ * @param family  - The Google Font family name.
+ * @param variant - Weight and/or style to fetch.
+ * @returns A single `FontConfig`.
+ *
+ * @example
+ * ```ts
+ * const bold = await googleFont("Inter", { weight: 700 });
+ * ```
+ */
+export declare function googleFont(family: string, variant: GoogleFontVariant): Promise<FontConfig>;
+/**
+ * Fetch multiple weight/style variants of a Google Font in one call.
+ *
+ * All variants are fetched in parallel for maximum throughput.
+ *
+ * @param family   - The Google Font family name.
+ * @param variants - Array of weight/style combinations to fetch.
+ * @returns An array of `FontConfig` objects, one per variant.
+ *
+ * @example
+ * ```ts
+ * const fonts = await googleFont("Inter", [
+ *   { weight: 400 },
+ *   { weight: 700 },
+ *   { weight: 700, style: "italic" },
+ * ]);
+ * createPlugin({ fonts, actions: [...] });
+ * ```
+ */
+export declare function googleFont(family: string, variants: GoogleFontVariant[]): Promise<FontConfig[]>;
+export {};

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/index.d.ts

@@ -23,7 +23,10 @@ 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, Controller, Coordinates, Size, 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, ActionDefinition, 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 { PluginManifestInfo, ActionManifestInfo, ManifestController, ManifestEncoderInfo, ManifestTriggerDescription, ManifestStateInfo, ManifestOSInfo, ManifestNodejsInfo, ManifestProfileInfo, } from './manifest-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

@@ -18,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, 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 };
+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/manifest-extract.d.ts

@@ -0,0 +1,32 @@
+import { ActionManifestInfo, ManifestActionSource } from './manifest-types';
+type ASTNode = Record<string, any>;
+export interface ExtractedAction {
+    uuid: string;
+    hasKey: boolean;
+    hasDial: boolean;
+    hasTouchStrip: boolean;
+    info: ActionManifestInfo | null;
+}
+/**
+ * Extract all `defineAction()` calls from an ESTree-compatible AST.
+ *
+ * Walks the entire AST looking for `defineAction({ uuid, key?, dial?,
+ * touchStrip?, info? })` patterns and returns the extracted metadata.
+ *
+ * Actions with `info.disabled: true` are included in the results but
+ * can be filtered by the caller.
+ *
+ * @param ast - ESTree-compatible AST (from Rollup's `this.parse()` or `moduleParsed`)
+ * @returns Array of extracted action metadata
+ */
+export declare function extractActionsFromAST(ast: ASTNode): ExtractedAction[];
+/**
+ * Convert an ExtractedAction to a ManifestActionSource for the
+ * manifest generation engine.
+ *
+ * The `key`/`dial`/`touchStrip` fields are set to `true` (truthy)
+ * when the corresponding property was present in the defineAction()
+ * call, enabling the controller derivation logic in manifest-gen.ts.
+ */
+export declare function extractedToActionSource(extracted: ExtractedAction): ManifestActionSource;
+export {};

package/dist/manifest-extract.js

@@ -0,0 +1,141 @@
+//#region src/manifest-extract.ts
+var SKIP_KEYS = new Set([
+	"type",
+	"start",
+	"end",
+	"loc",
+	"range"
+]);
+function walkAST(node, visitor) {
+	if (!node || typeof node !== "object" || !node.type) return;
+	visitor(node);
+	for (const key of Object.keys(node)) {
+		if (SKIP_KEYS.has(key)) continue;
+		const child = node[key];
+		if (Array.isArray(child)) {
+			for (const item of child) if (item && typeof item === "object" && item.type) walkAST(item, visitor);
+		} else if (child && typeof child === "object" && child.type) walkAST(child, visitor);
+	}
+}
+var UNEVALUABLE = Symbol("unevaluable");
+function evaluateStatic(node) {
+	if (!node) return UNEVALUABLE;
+	switch (node.type) {
+		case "Literal": return node.value;
+		case "ObjectExpression": {
+			const obj = {};
+			for (const prop of node.properties ?? []) {
+				if (prop.type === "SpreadElement") return UNEVALUABLE;
+				if (prop.type !== "Property") continue;
+				if (prop.computed) return UNEVALUABLE;
+				const key = prop.key.type === "Identifier" ? prop.key.name : prop.key.value;
+				if (typeof key !== "string") return UNEVALUABLE;
+				const value = evaluateStatic(prop.value);
+				if (value === UNEVALUABLE) return UNEVALUABLE;
+				obj[key] = value;
+			}
+			return obj;
+		}
+		case "ArrayExpression": {
+			const arr = [];
+			for (const el of node.elements ?? []) {
+				if (!el) {
+					arr.push(null);
+					continue;
+				}
+				if (el.type === "SpreadElement") return UNEVALUABLE;
+				const value = evaluateStatic(el);
+				if (value === UNEVALUABLE) return UNEVALUABLE;
+				arr.push(value);
+			}
+			return arr;
+		}
+		case "UnaryExpression":
+			if (node.operator === "-" && node.argument?.type === "Literal" && typeof node.argument.value === "number") return -node.argument.value;
+			if (node.operator === "!") {
+				const arg = evaluateStatic(node.argument);
+				if (arg === UNEVALUABLE) return UNEVALUABLE;
+				return !arg;
+			}
+			return UNEVALUABLE;
+		case "TemplateLiteral":
+			if (node.expressions?.length === 0 && node.quasis?.length === 1) return node.quasis[0]?.value?.cooked;
+			return UNEVALUABLE;
+		default: return UNEVALUABLE;
+	}
+}
+function isDefineActionCall(node) {
+	if (node.type !== "CallExpression") return false;
+	const callee = node.callee;
+	return callee?.type === "Identifier" && callee.name === "defineAction";
+}
+function extractFromDefineAction(node) {
+	const args = node.arguments;
+	if (!args || args.length === 0) return null;
+	const arg = args[0];
+	if (arg.type !== "ObjectExpression") return null;
+	const propMap = /* @__PURE__ */ new Map();
+	for (const prop of arg.properties ?? []) {
+		if (prop.type !== "Property" || prop.computed) continue;
+		const key = prop.key?.type === "Identifier" ? prop.key.name : prop.key?.value;
+		if (typeof key === "string") propMap.set(key, prop.value);
+	}
+	const uuidNode = propMap.get("uuid");
+	if (!uuidNode || uuidNode.type !== "Literal" || typeof uuidNode.value !== "string") return null;
+	const infoNode = propMap.get("info");
+	let info = null;
+	if (infoNode) {
+		const evaluated = evaluateStatic(infoNode);
+		if (evaluated !== UNEVALUABLE && typeof evaluated === "object" && evaluated !== null) {
+			const candidate = evaluated;
+			if (typeof candidate.name === "string" && typeof candidate.icon === "string") info = candidate;
+		}
+	}
+	return {
+		uuid: uuidNode.value,
+		hasKey: propMap.has("key"),
+		hasDial: propMap.has("dial"),
+		hasTouchStrip: propMap.has("touchStrip"),
+		info
+	};
+}
+/**
+* Extract all `defineAction()` calls from an ESTree-compatible AST.
+*
+* Walks the entire AST looking for `defineAction({ uuid, key?, dial?,
+* touchStrip?, info? })` patterns and returns the extracted metadata.
+*
+* Actions with `info.disabled: true` are included in the results but
+* can be filtered by the caller.
+*
+* @param ast - ESTree-compatible AST (from Rollup's `this.parse()` or `moduleParsed`)
+* @returns Array of extracted action metadata
+*/
+function extractActionsFromAST(ast) {
+	const results = [];
+	walkAST(ast, (node) => {
+		if (!isDefineActionCall(node)) return;
+		const extracted = extractFromDefineAction(node);
+		if (extracted) results.push(extracted);
+	});
+	return results;
+}
+/**
+* Convert an ExtractedAction to a ManifestActionSource for the
+* manifest generation engine.
+*
+* The `key`/`dial`/`touchStrip` fields are set to `true` (truthy)
+* when the corresponding property was present in the defineAction()
+* call, enabling the controller derivation logic in manifest-gen.ts.
+*/
+function extractedToActionSource(extracted) {
+	return {
+		uuid: extracted.uuid,
+		key: extracted.hasKey ? true : void 0,
+		dial: extracted.hasDial ? true : void 0,
+		touchStrip: extracted.hasTouchStrip ? true : void 0,
+		info: extracted.info ?? void 0
+	};
+}
+//#endregion
+export { extractActionsFromAST, extractedToActionSource };

package/dist/manifest-gen.d.ts

@@ -0,0 +1,52 @@
+import { ManifestConfig } from './manifest-types';
+export interface ManifestValidationError {
+    field: string;
+    message: string;
+}
+/**
+ * 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.
+ */
+export declare function validatePluginUUID(uuid: string): ManifestValidationError | 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.
+ */
+export declare function validateManifestConfig(config: ManifestConfig, warn?: (msg: string) => void): ManifestValidationError[];
+type JsonRecord = Record<string, any>;
+/**
+ * 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)
+ */
+export declare function buildManifestJson(config: ManifestConfig, codePath?: string): JsonRecord;
+/**
+ * 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
+ */
+export declare function generateManifestJsonString(config: ManifestConfig, codePath?: string): string;
+/**
+ * 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.
+ */
+export declare function writeManifestIfChanged(outPath: string, content: string): boolean;
+export {};