@fcannizzaro/streamdeck-react 0.1.10 → 0.1.12

package/dist/manifest-codegen.js

@@ -0,0 +1,110 @@
+import { dirname, join, resolve } from "node:path";
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+//#region src/manifest-codegen.ts
+/**
+* Find the manifest.json inside a `*.sdPlugin` directory.
+*
+* - If `explicit` is a string, it is resolved against `root`.
+* - If `explicit` is `false`, codegen is disabled (returns `null`).
+* - Otherwise, auto-detects by scanning `root` for `*.sdPlugin/manifest.json`.
+*/
+function findManifestPath(root, explicit, warn) {
+	if (explicit === false) return null;
+	if (typeof explicit === "string") {
+		const resolved = resolve(root, explicit);
+		if (!existsSync(resolved)) {
+			warn?.(`[@fcannizzaro/streamdeck-react] Manifest not found at ${resolved}`);
+			return null;
+		}
+		return resolved;
+	}
+	const sdPluginDirs = readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name.endsWith(".sdPlugin"));
+	if (sdPluginDirs.length === 0) return null;
+	if (sdPluginDirs.length > 1) warn?.(`[@fcannizzaro/streamdeck-react] Multiple .sdPlugin directories found. Using "${sdPluginDirs[0].name}". Set the \`manifest\` option to specify one explicitly.`);
+	const manifestPath = join(root, sdPluginDirs[0].name, "manifest.json");
+	return existsSync(manifestPath) ? manifestPath : null;
+}
+/**
+* Parse a Stream Deck plugin manifest and extract action metadata.
+* Returns an empty array on failure (with a warning).
+*/
+function parseManifest(path, warn) {
+	try {
+		const content = readFileSync(path, "utf-8");
+		const manifest = JSON.parse(content);
+		if (!Array.isArray(manifest.Actions)) {
+			warn?.(`[@fcannizzaro/streamdeck-react] manifest.json has no Actions array`);
+			return [];
+		}
+		const actions = [];
+		for (const action of manifest.Actions) {
+			if (!action.UUID) {
+				warn?.(`[@fcannizzaro/streamdeck-react] Skipping manifest action with missing UUID`);
+				continue;
+			}
+			actions.push({
+				uuid: action.UUID,
+				controllers: action.Controllers ?? ["Keypad"]
+			});
+		}
+		return actions;
+	} catch (err) {
+		warn?.(`[@fcannizzaro/streamdeck-react] Failed to parse manifest: ${err instanceof Error ? err.message : String(err)}`);
+		return [];
+	}
+}
+var HEADER = ["// This file is auto-generated by @fcannizzaro/streamdeck-react", "// Do not edit this file manually. It is regenerated from the plugin manifest."].join("\n");
+/**
+* Generate the `declare module` augmentation string from parsed actions.
+* Returns an empty string when there are no actions.
+*/
+function generateManifestDts(actions) {
+	if (actions.length === 0) return "";
+	return [
+		HEADER,
+		"",
+		"import \"@fcannizzaro/streamdeck-react\";",
+		"",
+		"declare module \"@fcannizzaro/streamdeck-react\" {",
+		"  interface ManifestActions {",
+		...actions.map((action) => {
+			const controllers = action.controllers.map((c) => `"${c}"`).join(", ");
+			return `    "${action.uuid}": {\n      controllers: readonly [${controllers}];\n    };`;
+		}),
+		"  }",
+		"}",
+		""
+	].join("\n");
+}
+/**
+* Write the generated `.d.ts` file 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 writeManifestDtsIfChanged(outPath, content) {
+	if (content === "") return false;
+	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;
+}
+/**
+* High-level helper: find, parse, generate, and write manifest types.
+*
+* @returns The resolved manifest path (for watch registration), or `null`.
+*/
+function generateManifestTypes(root, manifestOption, warn) {
+	const manifestPath = findManifestPath(root, manifestOption, warn);
+	if (!manifestPath) return null;
+	const content = generateManifestDts(parseManifest(manifestPath, warn));
+	return {
+		manifestPath,
+		written: writeManifestDtsIfChanged(resolve(root, "src/streamdeck-env.d.ts"), content)
+	};
+}
+//#endregion
+export { generateManifestTypes };

package/dist/plugin.js

@@ -1,178 +1,158 @@
+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 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: new Renderer({ fonts: config.fonts.map((f) => ({
-			name: f.name,
-			data: f.data,
-			weight: f.weight,
-			style: f.style
-		})) }),
+		renderer,
 		imageFormat: config.imageFormat ?? "png",
 		caching: config.caching ?? true,
-		devicePixelRatio: config.devicePixelRatio ?? 1
+		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, config.renderDebounceMs ?? 16, streamDeck, async (settings) => {
-		await streamDeck.settings.setGlobalSettings(settings);
+	const registry = new RootRegistry(renderConfig, adapter, async (settings) => {
+		await adapter.setGlobalSettings(settings);
 	}, config.wrapper);
-	streamDeck.settings.getGlobalSettings().then((gs) => {
+	adapter.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);
+	adapter.onGlobalSettingsChanged((settings) => {
+		registry.setGlobalSettings(settings);
 	});
-	for (const definition of config.actions) {
-		const singletonAction = createSingletonAction(definition, registry, config.onActionError);
-		streamDeck.actions.registerAction(singletonAction);
-	}
+	for (const definition of config.actions) registerActionWithAdapter(adapter, definition, registry, config.onActionError);
+	if (renderConfig.debug) metrics.enable();
 	if (config.devtools) startDevtoolsServer({
-		devtoolsName: streamDeck.info.plugin.uuid,
+		devtoolsName: adapter.pluginUUID,
 		registry,
 		renderConfig
 	});
 	return { async connect() {
-		await streamDeck.connect();
+		if (renderPool != null) renderPool.initialize().catch(() => {});
+		await adapter.connect();
 	} };
 }
-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";
-				if (isEncoder && definition.touchBar) {
-					registry.create(ev, definition.touchBar, definition);
+				if (isEncoder && definition.touchStrip) {
+					registry.create(ev, definition.touchStrip, definition);
 					return;
 				}
 				const component = isEncoder ? definition.dial ?? definition.key : definition.key;
 				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/host-config.js

@@ -1,4 +1,4 @@
-import { createTextVNode, createVNode } from "./vnode.js";
+import { clearParent, createTextVNode, createVNode, markContainerDirty, markDirty, setParent } from "./vnode.js";
 import { createContext } from "react";
 import { DefaultEventPriority } from "react-reconciler/constants.js";
 //#region src/reconciler/host-config.ts
@@ -46,6 +46,7 @@ var hostConfig = {
 		return false;
 	},
 	appendInitialChild(parent, child) {
+		child._parent = parent;
 		parent.children.push(child);
 	},
 	finalizeInitialChildren() {
@@ -81,42 +82,59 @@ var hostConfig = {
 		return null;
 	},
 	appendChild(parent, child) {
+		setParent(child, parent);
 		parent.children.push(child);
+		markDirty(parent);
 	},
 	appendChildToContainer(container, child) {
+		setParent(child, container);
 		container.children.push(child);
+		markContainerDirty(container);
 	},
 	insertBefore(parent, child, beforeChild) {
+		setParent(child, parent);
 		const index = parent.children.indexOf(beforeChild);
 		if (index >= 0) parent.children.splice(index, 0, child);
 		else parent.children.push(child);
+		markDirty(parent);
 	},
 	insertInContainerBefore(container, child, beforeChild) {
+		setParent(child, container);
 		const index = container.children.indexOf(beforeChild);
 		if (index >= 0) container.children.splice(index, 0, child);
 		else container.children.push(child);
+		markContainerDirty(container);
 	},
 	removeChild(parent, child) {
 		const index = parent.children.indexOf(child);
 		if (index >= 0) parent.children.splice(index, 1);
+		clearParent(child);
+		markDirty(parent);
 	},
 	removeChildFromContainer(container, child) {
 		const index = container.children.indexOf(child);
 		if (index >= 0) container.children.splice(index, 1);
+		clearParent(child);
+		markContainerDirty(container);
 	},
 	commitUpdate(instance, _type, _oldProps, newProps) {
 		const { children: _, ...cleanProps } = newProps;
 		instance.props = cleanProps;
+		instance._sortedPropKeys = void 0;
+		markDirty(instance);
 	},
 	commitTextUpdate(textInstance, _oldText, newText) {
 		textInstance.text = newText;
+		markDirty(textInstance);
 	},
 	hideInstance() {},
 	unhideInstance() {},
 	hideTextInstance() {},
 	unhideTextInstance() {},
 	clearContainer(container) {
+		for (const child of container.children) clearParent(child);
 		container.children = [];
+		markContainerDirty(container);
 	},
 	scheduleTimeout: setTimeout,
 	cancelTimeout: clearTimeout,

package/dist/reconciler/vnode.d.ts

@@ -1,9 +1,18 @@
-import { ReactElement } from 'react';
 export interface VNode {
     type: string;
     props: Record<string, unknown>;
     children: VNode[];
     text?: string;
+    /** @internal Back-pointer to parent VNode or VContainer for dirty propagation. */
+    _parent?: VNode | VContainer;
+    /** @internal True when this node or a descendant has been mutated since last flush. */
+    _dirty?: boolean;
+    /** @internal Cached Merkle hash for this subtree. */
+    _hash?: number;
+    /** @internal True when `_hash` is valid (invalidated on mutation). */
+    _hashValid?: boolean;
+    /** @internal Cached sorted prop keys for deterministic hashing. Invalidated when props change (commitUpdate). */
+    _sortedPropKeys?: string[];
 }
 export interface VContainer {
     children: VNode[];
@@ -11,8 +20,23 @@ export interface VContainer {
     lastSvgHash: number;
     renderCallback: () => void;
     renderTimer: ReturnType<typeof setTimeout> | null;
+    /** @internal Consecutive identical render count for duplicate detection. */
+    _dupCount: number;
+    /** @internal True when any child VNode has been mutated since last flush. */
+    _dirty: boolean;
 }
+/** Mark a node (and its ancestors up to the container) as dirty. */
+export declare function markDirty(node: VNode): void;
+/** Mark the container itself as dirty (for structural mutations at container level). */
+export declare function markContainerDirty(container: VContainer): void;
+/** Check if the container has any pending mutations. */
+export declare function isContainerDirty(container: VContainer): boolean;
+/** Clear all dirty flags in the tree after a successful render. */
+export declare function clearDirtyFlags(container: VContainer): void;
+/** Set back-pointer on a child node. */
+export declare function setParent(child: VNode, parent: VNode | VContainer): void;
+/** Clear back-pointer (e.g., when removing from tree). */
+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,5 +1,40 @@
-import { createElement } from "react";
 //#region src/reconciler/vnode.ts
+/** Mark a node (and its ancestors up to the container) as dirty. */
+function markDirty(node) {
+	let current = node;
+	while (current != null) {
+		if ("_dirty" in current && current._dirty) break;
+		current._dirty = true;
+		if ("type" in current) current._hashValid = false;
+		current = current._parent;
+	}
+}
+/** Mark the container itself as dirty (for structural mutations at container level). */
+function markContainerDirty(container) {
+	container._dirty = true;
+}
+/** Check if the container has any pending mutations. */
+function isContainerDirty(container) {
+	return container._dirty;
+}
+/** Clear all dirty flags in the tree after a successful render. */
+function clearDirtyFlags(container) {
+	container._dirty = false;
+	for (const child of container.children) clearNodeDirty(child);
+}
+function clearNodeDirty(node) {
+	if (!node._dirty) return;
+	node._dirty = false;
+	for (const child of node.children) clearNodeDirty(child);
+}
+/** Set back-pointer on a child node. */
+function setParent(child, parent) {
+	child._parent = parent;
+}
+/** Clear back-pointer (e.g., when removing from tree). */
+function clearParent(child) {
+	child._parent = void 0;
+}
 function createVNode(type, props) {
 	return {
 		type,
@@ -21,15 +56,10 @@ function createVContainer(renderCallback) {
 		scheduledRender: false,
 		lastSvgHash: 0,
 		renderCallback,
-		renderTimer: null
+		renderTimer: null,
+		_dupCount: 0,
+		_dirty: true
 	};
 }
-function vnodeToElement(node) {
-	if (node.type === "#text") return node.text ?? "";
-	const { children: _children, className, ...restProps } = node.props;
-	if (typeof className === "string" && className.length > 0) restProps.tw = (typeof restProps.tw === "string" ? restProps.tw + " " : "") + className;
-	const childElements = node.children.map(vnodeToElement);
-	return createElement(node.type, restProps, ...childElements);
-}
 //#endregion
-export { createTextVNode, createVContainer, createVNode, vnodeToElement };
+export { clearDirtyFlags, clearParent, createTextVNode, createVContainer, createVNode, isContainerDirty, markContainerDirty, markDirty, setParent };

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

@@ -0,0 +1,19 @@
+export declare class BufferPool {
+    private pools;
+    /** Acquire a zeroed buffer of the given size. Reuses a pooled buffer if available. */
+    acquire(size: number): Buffer;
+    /** Return a buffer to the pool for future reuse. */
+    release(buf: Buffer): void;
+    /** Clear all pooled buffers. */
+    clear(): void;
+    /** Current pool statistics. */
+    get stats(): {
+        buckets: number;
+        totalBuffers: number;
+        totalBytes: number;
+    };
+}
+/** Get the shared buffer pool. */
+export declare function getBufferPool(): BufferPool;
+/** Reset the shared pool (for testing). */
+export declare function resetBufferPool(): void;

package/dist/render/buffer-pool.js

@@ -0,0 +1,51 @@
+//#region src/render/buffer-pool.ts
+/** Maximum number of buffers to retain per size bucket (prevents unbounded growth). */
+var MAX_POOL_SIZE_PER_BUCKET = 8;
+var BufferPool = class {
+	pools = /* @__PURE__ */ new Map();
+	/** Acquire a zeroed buffer of the given size. Reuses a pooled buffer if available. */
+	acquire(size) {
+		const pool = this.pools.get(size);
+		if (pool != null && pool.length > 0) {
+			const buf = pool.pop();
+			buf.fill(0);
+			return buf;
+		}
+		return Buffer.alloc(size);
+	}
+	/** Return a buffer to the pool for future reuse. */
+	release(buf) {
+		let pool = this.pools.get(buf.length);
+		if (pool == null) {
+			pool = [];
+			this.pools.set(buf.length, pool);
+		}
+		if (pool.length < MAX_POOL_SIZE_PER_BUCKET) pool.push(buf);
+	}
+	/** Clear all pooled buffers. */
+	clear() {
+		this.pools.clear();
+	}
+	/** Current pool statistics. */
+	get stats() {
+		let totalBuffers = 0;
+		let totalBytes = 0;
+		for (const [size, pool] of this.pools) {
+			totalBuffers += pool.length;
+			totalBytes += size * pool.length;
+		}
+		return {
+			buckets: this.pools.size,
+			totalBuffers,
+			totalBytes
+		};
+	}
+};
+var sharedPool = null;
+/** Get the shared buffer pool. */
+function getBufferPool() {
+	if (sharedPool == null) sharedPool = new BufferPool();
+	return sharedPool;
+}
+//#endregion
+export { getBufferPool };

package/dist/render/cache.d.ts

@@ -1 +1,30 @@
+import { VNode, VContainer } from '../reconciler/vnode';
+/**
+ * Hash a raw byte buffer (Uint8Array or Buffer) or string.
+ *
+ * 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 full byte-by-byte FNV-1a.
+ */
 export declare function fnv1a(input: string | Uint8Array | Buffer): number;
+/** Feed a string into a running FNV-1a hash. */
+export declare function fnv1aString(str: string, hash: number): number;
+/** Feed a uint32 value into a running FNV-1a hash (4 bytes, big-endian). */
+export declare function fnv1aU32(value: number, hash: number): number;
+/** Hash an arbitrary JS value into a running FNV-1a hash. */
+export declare function hashValue(value: unknown, hash: number, depth?: number): number;
+/**
+ * Compute (or return cached) Merkle hash for a single VNode.
+ * The hash incorporates: type, text, props (sorted, functions skipped),
+ * children count, and children hashes (recursive).
+ */
+export declare function computeHash(node: VNode): number;
+/**
+ * Compute the Merkle hash for an entire VContainer tree.
+ * Returns 0 for empty containers.
+ */
+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 computeTouchStripSegmentCacheKey(treeHash: number, width: number, height: number, dpr: number, columns: number[]): number;