@jasonshimmy/custom-elements-runtime 2.5.2 → 2.5.6

package/dist/runtime/monitoring/health-monitor.d.ts

@@ -16,84 +16,41 @@ interface HealthReport {
     timestamp: number;
     recommendations: string[];
 }
-export declare class HealthMonitor {
-    private metrics;
-    private readonly maxHistorySize;
-    private readonly checkInterval;
-    private intervalId;
-    private listeners;
-    constructor();
-    /**
-     * Initialize default health metrics
-     */
-    private initializeMetrics;
-    /**
-     * Add a new health metric
-     */
-    private addMetric;
-    /**
-     * Update a specific health metric
-     */
+export type { HealthReport };
+/**
+ * Public interface for a health monitor instance.
+ * All state is managed internally via closures — no class syntax.
+ */
+export interface HealthMonitorInstance {
+    /** Update a specific health metric value */
     updateMetric(name: string, value: number): void;
-    /**
-     * Calculate health status based on value and threshold
-     */
-    private calculateStatus;
-    /**
-     * Get current health report
-     */
+    /** Get the current health report */
     getHealthReport(): HealthReport;
-    /**
-     * Generate actionable recommendations based on metrics
-     */
-    private generateRecommendations;
-    /**
-     * Start periodic health monitoring
-     */
-    private startMonitoring;
-    /**
-     * Perform comprehensive health check
-     */
-    private performHealthCheck;
-    /**
-     * Update memory-related metrics
-     */
-    private updateMemoryMetrics;
-    /**
-     * Add health report listener
-     */
+    /** Add a listener to be notified when a health check runs */
     addListener(listener: (report: HealthReport) => void): void;
-    /**
-     * Remove health report listener
-     */
+    /** Remove a previously registered listener */
     removeListener(listener: (report: HealthReport) => void): void;
-    /**
-     * Notify all listeners of health report
-     */
-    private notifyListeners;
-    /**
-     * Stop health monitoring
-     */
+    /** Stop the periodic health monitoring timer */
     stop(): void;
-    /**
-     * Get specific metric history for analysis
-     */
+    /** Get historical values for a specific metric */
     getMetricHistory(name: string): number[];
-    /**
-     * Clear all metrics history
-     */
+    /** Clear all metric history */
     clearHistory(): void;
 }
 /**
- * Get the global health monitor instance
+ * Create a new health monitor instance.
+ * All mutable state lives in closures — no `class` or `this`.
+ */
+export declare function createHealthMonitor(): HealthMonitorInstance;
+/**
+ * Get the global health monitor singleton instance.
  */
-export declare function getHealthMonitor(): HealthMonitor;
+export declare function getHealthMonitor(): HealthMonitorInstance;
 /**
- * Update a health metric from anywhere in the framework
+ * Update a health metric from anywhere in the framework.
  */
 export declare function updateHealthMetric(name: string, value: number): void;
 /**
- * Get current health status
+ * Get the current health status report.
  */
 export declare function getHealthStatus(): HealthReport;
-export {};

package/dist/runtime/reactive.d.ts

@@ -1,3 +1,4 @@
+import type { WatchOptions } from './types';
 /**
  * Global reactive system for tracking dependencies and triggering updates
  */
@@ -71,6 +72,22 @@ export declare class ReactiveState<T> {
     constructor(initialValue: T);
     get value(): T;
     set value(newValue: T);
+    /**
+     * Read the current value without registering a reactive dependency.
+     * Useful for internal infrastructure (e.g. stable hook slots) that must
+     * inspect the stored value without re-triggering the containing component.
+     * @internal
+     */
+    peek(): T;
+    /**
+     * Set the initial value without triggering any reactive updates or warnings.
+     * Only intended for internal/infrastructure use (e.g. storing a stable hook
+     * handle in a reactive slot without causing a spurious re-render).
+     * The value is stored as-is without reactive proxy wrapping so that opaque
+     * objects (e.g. TeleportHandle) are not accidentally instrumented.
+     * @internal
+     */
+    initSilent(value: T): void;
     addDependent(componentId: string): void;
     removeDependent(componentId: string): void;
     getDependents(): Set<string>;
@@ -101,18 +118,37 @@ export declare function ref<T>(initialValue: T): ReactiveState<T>;
  */
 export declare function isReactiveState(v: unknown): v is ReactiveState<unknown>;
 /**
- * Create computed state that derives from other reactive state
+ * Create computed state that derives from other reactive state.
+ * The result is cached and only recomputed when tracked reactive dependencies change.
  *
  * @example
  * ```ts
  * const firstName = ref('John');
  * const lastName = ref('Doe');
  * const fullName = computed(() => `${firstName.value} ${lastName.value}`);
+ * console.log(fullName.value); // 'John Doe' — cached until firstName or lastName changes
  * ```
  */
 export declare function computed<T>(fn: () => T): {
     readonly value: T;
 };
+/**
+ * Run a side-effect function immediately and automatically re-run it whenever
+ * any reactive state accessed inside `fn` changes. Similar to Vue's `watchEffect`.
+ *
+ * @returns A cleanup function that stops the effect.
+ *
+ * @example
+ * ```ts
+ * const count = ref(0);
+ * const stop = watchEffect(() => {
+ *   document.title = `Count: ${count.value}`;
+ * });
+ * count.value++; // automatically re-runs the effect
+ * stop(); // cancel the effect
+ * ```
+ */
+export declare function watchEffect(fn: () => void): () => void;
 /**
  * Create a watcher that runs when dependencies change
  *
@@ -124,9 +160,5 @@ export declare function computed<T>(fn: () => T): {
  * });
  * ```
  */
-export declare function watch<T>(source: ReactiveState<T>, callback: (newValue: T, oldValue?: T) => void, options?: {
-    immediate?: boolean;
-}): () => void;
-export declare function watch<T>(source: () => T, callback: (newValue: T, oldValue?: T) => void, options?: {
-    immediate?: boolean;
-}): () => void;
+export declare function watch<T>(source: ReactiveState<T>, callback: (newValue: T, oldValue?: T) => void, options?: WatchOptions): () => void;
+export declare function watch<T>(source: () => T, callback: (newValue: T, oldValue?: T) => void, options?: WatchOptions): () => void;

package/dist/runtime/render.d.ts

@@ -11,18 +11,34 @@ export declare function registerChildComponent(shadowRoot: ShadowRoot, childEl:
  */
 export declare function unregisterChildComponent(shadowRoot: ShadowRoot, childEl: HTMLElement): void;
 /**
- * Renders the component output.
+ * Renders the component output with optimized error handling and loading states.
  */
 export declare function renderComponent<S extends object, C extends object, P extends object, T extends object>(shadowRoot: ShadowRoot | null, cfg: ComponentConfig<S, C, P, T>, context: ComponentContext<S, C, P, T>, refs: Refs['refs'], setHtmlString: (html: string) => void, setLoading: (val: boolean) => void, setError: (err: Error | null) => void, applyStyle: (html: string) => void): void;
 /**
- * Renders VNode(s) to the shadowRoot.
+ * Renders VNode(s) to the shadowRoot with performance optimizations.
  */
 export declare function renderOutput<S extends object, C extends object, P extends object, T extends object>(shadowRoot: ShadowRoot | null, output: VNode | VNode[], context: ComponentContext<S, C, P, T>, refs: Refs['refs'], setHtmlString: (html: string) => void): void;
 /**
- * Debounced render request with infinite loop protection.
+ * Advanced render request with intelligent throttling and loop detection.
  */
 export declare function requestRender(renderFn: () => void, lastRenderTime: number, renderCount: number, setLastRenderTime: (t: number) => void, setRenderCount: (c: number) => void, renderTimeoutId: ReturnType<typeof setTimeout> | null, setRenderTimeoutId: (id: ReturnType<typeof setTimeout> | null) => void): void;
 /**
- * Applies styles to the shadowRoot with improved structure and maintainability.
+ * Optimized style application with intelligent caching and generation tracking.
  */
 export declare function applyStyle<S extends object, C extends object, P extends object, T extends object>(shadowRoot: ShadowRoot | null, context: ComponentContext<S, C, P, T>, htmlString: string, styleSheet: CSSStyleSheet | null, setStyleSheet: (sheet: CSSStyleSheet | null) => void): void;
+/**
+ * Clean up render-related caches for a shadow root
+ * @internal
+ */
+export declare function cleanupRenderCaches(shadowRoot: ShadowRoot): void;
+/**
+ * Get render performance metrics for debugging
+ * @internal
+ */
+export declare function getRenderStats(shadowRoot: ShadowRoot): {
+    renderCount: number;
+    lastRenderTime: number;
+    isThrottled: boolean;
+    childComponentCount: number;
+    hasCachedHtml: boolean;
+};

package/dist/runtime/scheduler.d.ts

@@ -1,3 +1,12 @@
+/**
+ * Scheduling priority for update tasks.
+ *
+ * - `'immediate'` — Run synchronously before returning (use sparingly).
+ * - `'normal'`    — Batch via microtask (default).
+ * - `'idle'`      — Defer to browser idle time via `requestIdleCallback`
+ *                    (time-sliced, non-blocking rendering for low-priority work).
+ */
+export type UpdatePriority = 'immediate' | 'normal' | 'idle';
 declare class UpdateScheduler {
     private pendingUpdates;
     private isFlushScheduled;
@@ -6,6 +15,8 @@ declare class UpdateScheduler {
     private lastCleanup;
     private readonly CLEANUP_INTERVAL;
     private readonly MAX_PENDING_SIZE;
+    private pendingIdleUpdates;
+    private idleCallbackHandle;
     constructor();
     /**
      * Schedule an update to be executed in the next microtask
@@ -17,7 +28,8 @@ declare class UpdateScheduler {
      */
     private scheduleFlush;
     /**
-     * Execute all pending updates
+     * Execute all pending updates with priority ordering
+     * Execute all pending updates with priority ordering
      */
     private flush;
     /**
@@ -52,12 +64,54 @@ declare class UpdateScheduler {
      * Emergency cleanup when pending updates exceed safe limits
      */
     private performEmergencyCleanup;
+    /**
+     * Schedule an update with an explicit priority level.
+     *
+     * - `'immediate'` — Runs synchronously before returning.
+     * - `'normal'`    — Default microtask batching (same as `schedule()`).
+     * - `'idle'`      — Deferred to browser idle time via `requestIdleCallback`
+     *                    with time-slicing to avoid blocking the main thread.
+     *                    Falls back to a 5 ms `setTimeout` when
+     *                    `requestIdleCallback` is unavailable (e.g. Safari < 16).
+     *
+     * @example Defer a low-priority analytics flush
+     * ```ts
+     * scheduleWithPriority(() => flushAnalytics(), 'idle');
+     * ```
+     */
+    scheduleWithPriority(update: () => void, priority?: UpdatePriority, componentId?: string): void;
+    /**
+     * Schedule a flush of idle-priority updates.
+     * Uses `requestIdleCallback` when available; falls back to a short `setTimeout`.
+     */
+    private scheduleIdleFlush;
+    /**
+     * Process pending idle-priority updates in a time-sliced manner.
+     * Yields back to the browser when the deadline's `timeRemaining()` reaches
+     * zero and reschedules any unprocessed work.
+     */
+    private flushIdleUpdates;
 }
 export declare const updateScheduler: UpdateScheduler;
 /**
- * Schedule a DOM update to be batched with optional component identity
+ * Schedule a DOM update to be batched with optional component identity and priority
+ * Schedule a DOM update to be batched with optional component identity and priority
  */
 export declare function scheduleDOMUpdate(update: () => void, componentId?: string): void;
+/**
+ * Schedule an update with explicit priority.
+ * See `UpdateScheduler.scheduleWithPriority` for full documentation.
+ *
+ * @example
+ * ```ts
+ * // Defer low-priority work to browser idle time (time-sliced, non-blocking)
+ * scheduleWithPriority(() => updateAnalyticsDashboard(), 'idle');
+ *
+ * // Run a critical update before any async code resumes
+ * scheduleWithPriority(() => updateCriticalUI(), 'immediate');
+ * ```
+ */
+export declare function scheduleWithPriority(update: () => void, priority?: UpdatePriority, componentId?: string): void;
 /**
  * Force flush any pending DOM updates immediately. This is useful in
  * test environments or callers that require synchronous guarantees after
@@ -66,4 +120,17 @@ export declare function scheduleDOMUpdate(update: () => void, componentId?: stri
  * rendered DOM changes.
  */
 export declare function flushDOMUpdates(): void;
+/**
+ * Returns a Promise that resolves after the next DOM update cycle completes.
+ * Equivalent to Vue's `nextTick()` — useful when you need to observe DOM
+ * state that reflects the latest reactive changes.
+ *
+ * @example
+ * ```ts
+ * count.value++;
+ * await nextTick();
+ * console.log(element.shadowRoot.querySelector('span').textContent); // updated
+ * ```
+ */
+export declare function nextTick(): Promise<void>;
 export {};

package/dist/runtime/template-compiler/impl.d.ts

@@ -0,0 +1,14 @@
+import type { VNode } from '../types';
+/**
+ * Transform VNodes with :when directive into anchor blocks for conditional rendering
+ */
+export declare function transformWhenDirective(vnode: VNode): VNode;
+/**
+ * Internal implementation allowing an optional compile context for :model.
+ * Fixes:
+ *  - Recognize interpolation markers embedded in text ("World{{1}}") and replace them.
+ *  - Skip empty arrays from directives so markers don't leak as text.
+ *  - Pass AnchorBlocks through (and deep-normalize their children's keys) so the renderer can mount/patch them surgically.
+ *  - Do not rewrap interpolated VNodes (preserve their keys); only fill in missing keys.
+ */
+export declare function htmlImpl(strings: TemplateStringsArray, values: unknown[], context?: Record<string, unknown>): VNode | VNode[];

package/dist/runtime/template-compiler/lru-cache.d.ts

@@ -0,0 +1,20 @@
+import type { VNode } from '../types';
+export declare class LRUCache<K, V> {
+    private map;
+    private maxSize;
+    private accessOrder;
+    private accessCounter;
+    constructor(maxSize: number);
+    get(key: K): V | undefined;
+    set(key: K, value: V): void;
+    private evictLRU;
+    has(key: K): boolean;
+    clear(): void;
+    get size(): number;
+}
+export declare const getCacheSize: () => number;
+export declare const TEMPLATE_COMPILE_CACHE: LRUCache<string, VNode | VNode[]>;
+/**
+ * Clear the template compile cache (useful for tests)
+ */
+export declare function clearTemplateCompileCache(): void;

package/dist/runtime/template-compiler/props-parser.d.ts

@@ -0,0 +1,15 @@
+export interface ParsePropsResult {
+    props: Record<string, unknown>;
+    attrs: Record<string, unknown>;
+    directives: Record<string, {
+        value: unknown;
+        modifiers: string[];
+        arg?: string;
+    }>;
+    bound: string[];
+}
+/**
+ * Validates event handlers to prevent common mistakes that lead to infinite loops
+ */
+export declare function validateEventHandler(value: unknown, eventName: string): void;
+export declare function parseProps(str: string, values?: unknown[], context?: Record<string, unknown>): ParsePropsResult;

package/dist/runtime/template-compiler/vnode-utils.d.ts

@@ -0,0 +1,5 @@
+import type { VNode } from '../types';
+export declare function h(tag: string, props?: Record<string, unknown>, children?: VNode[] | string, key?: string | number): VNode;
+export declare function isAnchorBlock(v: unknown): boolean;
+export declare function isElementVNode(v: unknown): v is VNode;
+export declare function ensureKey(v: VNode, k?: string): VNode;

package/dist/runtime/template-compiler.d.ts

@@ -1,32 +1,9 @@
+export type { ParsePropsResult } from './template-compiler/props-parser';
+export { h, isAnchorBlock, isElementVNode, ensureKey } from './template-compiler/vnode-utils';
+export { LRUCache, getCacheSize, TEMPLATE_COMPILE_CACHE, clearTemplateCompileCache } from './template-compiler/lru-cache';
+export { parseProps, validateEventHandler } from './template-compiler/props-parser';
+export { transformWhenDirective, htmlImpl } from './template-compiler/impl';
 import type { VNode } from './types';
-export declare function h(tag: string, props?: Record<string, unknown>, children?: VNode[] | string, key?: string | number): VNode;
-export declare function isAnchorBlock(v: unknown): boolean;
-export declare function isElementVNode(v: unknown): v is VNode;
-export declare function ensureKey(v: VNode, k?: string): VNode;
-export interface ParsePropsResult {
-    props: Record<string, unknown>;
-    attrs: Record<string, unknown>;
-    directives: Record<string, {
-        value: unknown;
-        modifiers: string[];
-        arg?: string;
-    }>;
-    bound: string[];
-}
-export declare function parseProps(str: string, values?: unknown[], context?: Record<string, unknown>): ParsePropsResult;
-/**
- * Internal implementation allowing an optional compile context for :model.
- * Fixes:
- *  - Recognize interpolation markers embedded in text ("World{{1}}") and replace them.
- *  - Skip empty arrays from directives so markers don't leak as text.
- *  - Pass AnchorBlocks through (and deep-normalize their children's keys) so the renderer can mount/patch them surgically.
- *  - Do not rewrap interpolated VNodes (preserve their keys); only fill in missing keys.
- */
-export declare function htmlImpl(strings: TemplateStringsArray, values: unknown[], context?: Record<string, unknown>): VNode | VNode[];
-/**
- * Clear the template compile cache (useful for tests)
- */
-export declare function clearTemplateCompileCache(): void;
 /**
  * Default export: plain html.
  */

package/dist/runtime/types.d.ts

@@ -44,6 +44,16 @@ export interface AnchorBlockVNode extends VNode {
 export type LifecycleKeys = 'onConnected' | 'onDisconnected' | 'onAttributeChanged' | 'onError';
 export interface WatchOptions {
     immediate?: boolean;
+    /**
+     * When `true`, the watcher tracks nested object/array property mutations.
+     * The callback receives deep-cloned snapshots of the new and old values so
+     * before/after state can be compared.
+     *
+     * Note: because deep watching bypasses reference equality, the callback fires
+     * on every nested mutation even if the resulting plain-object value is
+     * structurally identical. Use a shallow watcher (default) when you only need
+     * to detect `.value` reassignment.
+     */
     deep?: boolean;
 }
 export type WatchCallback<T = unknown, S = unknown> = (newValue: T, oldValue: T, context: S) => void;

package/dist/runtime/vdom-directives.d.ts

@@ -0,0 +1,71 @@
+/**
+ * vdom-directives.ts
+ *
+ * Directive processors for the virtual DOM. Handles `:model`, `:bind`,
+ * `:show`, `:class`, `:style`, and `:ref` directives as well as the
+ * top-level `processDirectives` coordinator.
+ */
+import { type PropsMap } from './vdom-helpers';
+/**
+ * Process :model directive for two-way data binding
+ * @param value
+ * @param modifiers
+ * @param props
+ * @param attrs
+ * @param listeners
+ * @param context
+ * @param el
+ * @returns
+ */
+export declare function processModelDirective(value: string | unknown, modifiers: string[], props: Record<string, unknown>, attrs: Record<string, unknown>, listeners: Record<string, EventListener>, context?: Record<string, unknown>, el?: Element, arg?: string): void;
+/**
+ * Process :bind directive for attribute/property binding
+ * @param value
+ * @param props
+ * @param attrs
+ * @param context
+ * @returns
+ */
+export declare function processBindDirective(value: unknown, props: PropsMap, attrs: PropsMap, context?: Record<string, unknown>, el?: Element): void;
+/**
+ * Process :show directive for conditional display
+ * @param value
+ * @param attrs
+ * @param context
+ * @returns
+ */
+export declare function processShowDirective(value: unknown, attrs: Record<string, unknown>, context?: Record<string, unknown>): void;
+export declare function processClassDirective(value: unknown, attrs: Record<string, unknown>, context?: Record<string, unknown>, originalVnodeAttrs?: Record<string, unknown>): void;
+/**
+ * Process :style directive for dynamic inline styles
+ * @param value
+ * @param attrs
+ * @param context
+ * @returns
+ */
+export declare function processStyleDirective(value: unknown, attrs: Record<string, unknown>, context?: Record<string, unknown>): void;
+/**
+ * Process :ref directive for element references
+ * @param value
+ * @param props
+ * @param context
+ * @returns
+ */
+export declare function processRefDirective(value: unknown, props: Record<string, unknown>, context?: Record<string, unknown>): void;
+/**
+ * Process directives and return merged props, attrs, and event listeners
+ * @param directives
+ * @param context
+ * @param el
+ * @param vnodeAttrs
+ * @returns
+ */
+export declare function processDirectives(directives: Record<string, {
+    value: unknown;
+    modifiers: string[];
+    arg?: string;
+}>, context?: Record<string, unknown>, el?: Element, vnodeAttrs?: PropsMap): {
+    props: Record<string, unknown>;
+    attrs: Record<string, unknown>;
+    listeners: Record<string, EventListener>;
+};

package/dist/runtime/vdom-helpers.d.ts

@@ -0,0 +1,126 @@
+/**
+ * vdom-helpers.ts
+ *
+ * Private utility functions and shared internal types for the virtual DOM.
+ * These are consumed by vdom-directives.ts and vdom-patch.ts.
+ * Keeping them here avoids circular imports and enables tree-shaking.
+ *
+ * Public API (for use by vdom-patch / vdom-directives only):
+ *   hasValueProp       — structural check: object has a `.value` property
+ *   unwrapValue        — unwrap reactive / wrapper objects to their inner value
+ *   writebackAttr      — mutate oldProps.attrs[key] to track applied values
+ *   isNativeControl    — true for input / select / textarea / button elements
+ *   coerceBooleanForNative — coerce a value to boolean for native attributes
+ *   eventNameFromKey   — "onClick" → "click", "onUpdate:name" → "update:name"
+ *   isBooleanishForProps — true when val is a clear boolean-ish primitive
+ */
+/** A loose map of property names to arbitrary values used throughout the VDOM. */
+export type PropsMap = Record<string, unknown>;
+/**
+ * Directive specification as produced by the template compiler and consumed
+ * by `processDirectives`.
+ */
+export interface DirectiveSpec {
+    value: unknown;
+    modifiers: string[];
+    arg?: string;
+}
+/**
+ * The `props` bag attached to a VNode. Used as the parameter / return type
+ * for patchProps, createElement, and VNode diffing helpers.
+ */
+export interface VNodePropBag {
+    key?: string;
+    props?: Record<string, unknown>;
+    attrs?: Record<string, unknown>;
+    directives?: Record<string, DirectiveSpec>;
+    ref?: string;
+    reactiveRef?: {
+        value: unknown;
+        [key: string]: unknown;
+    };
+    /** Compiler-provided hint: whether this VNode represents a custom element. */
+    isCustomElement?: boolean;
+    /** Transition group metadata forwarded from `<Transition>`. */
+    _transitionGroup?: {
+        name?: string;
+        appear?: boolean;
+        mode?: 'out-in' | 'in-out' | 'default';
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+}
+/**
+ * Extension of `globalThis` used exclusively for internal VDom test-env probes
+ * and debug diagnostics. Never rely on these properties in production code.
+ */
+export interface VDomGlobal {
+    process?: {
+        env?: {
+            NODE_ENV?: string;
+        };
+    };
+    __vitest__?: unknown;
+    __VDOM_DISABLED_PROMOTIONS?: unknown[];
+}
+/**
+ * Returns `true` when `val` is an object that exposes a `.value` property.
+ * This is a structural (duck-type) check used in the VDOM prop-diffing loop
+ * to detect value-wrapper objects that are *not* identified as ReactiveState
+ * by `isReactiveState()` (e.g. plain `{ value: 42 }` bags).
+ *
+ * Note: ReactiveState instances also satisfy this check; callers should test
+ * `isReactiveState(val)` first and only fall through to `hasValueProp` for the
+ * non-reactive wrapper case.
+ */
+export declare function hasValueProp(val: unknown): boolean;
+/**
+ * Unwrap a reactive-state or value-wrapper object to its inner value.
+ * If `val` is an object with a `.value` property the inner value is returned;
+ * otherwise `val` is returned as-is (including primitives, null, undefined).
+ *
+ * @example
+ * unwrapValue(ref(42))  // → 42
+ * unwrapValue({ value: 'hello' })  // → 'hello'
+ * unwrapValue('plain')  // → 'plain'
+ */
+export declare function unwrapValue(val: unknown): unknown;
+/**
+ * Write `val` back into `oldProps.attrs[key]` so that subsequent diff passes
+ * see the most recently applied attribute value without re-reading the DOM.
+ *
+ * When `val` is `undefined` the entry is *deleted* from `oldProps.attrs`
+ * (attribute was removed).
+ *
+ * Accepts `undefined` for `oldProps` to simplify call sites where the props
+ * bag may not have been initialised yet (e.g. `createElement` paths).
+ */
+export declare function writebackAttr(oldProps: VNodePropBag | undefined, key: string, val: unknown): void;
+/**
+ * Returns `true` when `el` is a native form control (input, select, textarea,
+ * or button). Used to gate attribute/property coercion logic that only applies
+ * to native control elements.
+ */
+export declare function isNativeControl(el: Element): boolean;
+/**
+ * Coerce `val` to a boolean for use with native element `.disabled` (and other
+ * boolean HTML attributes). Handles reactive/wrapper unwrapping, the string
+ * literals `'true'`/`'false'`, and falsy zero/empty-string values.
+ */
+export declare function coerceBooleanForNative(val: unknown): boolean;
+/**
+ * Convert an `onXxx` prop key to the corresponding DOM event name.
+ *
+ * @example
+ * eventNameFromKey('onClick')      // → 'click'
+ * eventNameFromKey('onMouseOver')  // → 'mouseOver'  (EventManager normalises case)
+ * eventNameFromKey('onUpdate:name') // → 'update:name'
+ */
+export declare function eventNameFromKey(key: string): string;
+/**
+ * Returns `true` when `val` is a clear boolean-ish primitive — i.e. one of
+ * `true`, `false`, `'true'`, or `'false'`. Used to decide whether a `:bind`
+ * prop candidate should be treated as the authoritative source for a native
+ * `disabled` attribute rather than falling back to the merged attrs value.
+ */
+export declare function isBooleanishForProps(val: unknown): boolean;