@jasonshimmy/custom-elements-runtime 2.5.1 → 2.5.5

package/dist/runtime/scheduler.d.ts

@@ -1,23 +1,136 @@
+/**
+ * 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;
+    private isFlushing;
+    private readonly testEnv;
+    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
      * Uses component identity to deduplicate multiple render requests for the same component
      */
     schedule(update: () => void, componentId?: string): void;
     /**
-     * Execute all pending updates
+     * Schedule the flush operation based on environment
+     */
+    private scheduleFlush;
+    /**
+     * Execute all pending updates with priority ordering
+     * Execute all pending updates with priority ordering
      */
     private flush;
+    /**
+     * Force flush any pending DOM updates immediately. This is useful in
+     * test environments or callers that require synchronous guarantees after
+     * state changes. Prefer relying on the scheduler's automatic flush when
+     * possible; use this only when a caller needs to synchronously observe
+     * rendered DOM changes.
+     */
+    flushImmediately(): void;
     /**
      * Get the number of pending updates
      */
     get pendingCount(): number;
+    /**
+     * Check if there are pending updates
+     */
+    get hasPendingUpdates(): boolean;
+    /**
+     * Check if currently flushing updates
+     */
+    get isFlushingUpdates(): boolean;
+    /**
+     * Schedule periodic cleanup to prevent memory leaks
+     */
+    private schedulePeriodicCleanup;
+    /**
+     * Perform periodic cleanup of stale entries
+     */
+    private performPeriodicCleanup;
+    /**
+     * 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
+ * state changes. Prefer relying on the scheduler's automatic flush when
+ * possible; use this only when a caller needs to synchronously observe
+ * 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;

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

@@ -0,0 +1,67 @@
+/**
+ * vdom-patch.ts
+ *
+ * Core virtual DOM patching and rendering engine. Provides:
+ * - `cleanupRefs`    — recursively remove event listeners and clear ref entries
+ * - `assignKeysDeep` — recursively assign stable keys to VNode trees
+ * - `patchProps`     — diff and apply prop/attr/directive changes to a DOM element
+ * - `createElement`  — create a new DOM element from a VNode descriptor
+ * - `patchChildren`  — reconcile a list of child VNodes against real DOM children
+ * - `patch`          — top-level diff/patch driver for a single VNode
+ * - `vdomRenderer`   — entry-point renderer for a shadow root or container
+ */
+import type { VNode, VDomRefs } from './types';
+import { type VNodePropBag } from './vdom-helpers';
+export declare function cleanupRefs(node: Node, refs?: VDomRefs): void;
+/**
+ * Assign unique keys to VNodes for efficient rendering
+ * @param nodeOrNodes
+ * @param baseKey
+ * @returns
+ */
+export declare function assignKeysDeep(nodeOrNodes: VNode | VNode[], baseKey: string): VNode | VNode[];
+/**
+ * Patch props on an element.
+ * Only update changed props, remove old, add new.
+ * @param el
+ * @param oldProps
+ * @param newProps
+ * @param context
+ */
+export declare function patchProps(el: HTMLElement, oldProps: VNodePropBag, newProps: VNodePropBag, context?: Record<string, unknown>): void;
+/**
+ * Create a DOM element from a VNode.
+ * @param vnode
+ * @param context
+ * @param refs
+ * @returns
+ */
+export declare function createElement(vnode: VNode | string, context?: Record<string, unknown>, refs?: VDomRefs, parentNamespace?: string | null): Node;
+/**
+ * Patch children using keys for node matching.
+ * @param parent
+ * @param oldChildren
+ * @param newChildren
+ * @param context
+ * @param refs
+ * @returns
+ */
+export declare function patchChildren(parent: HTMLElement, oldChildren: VNode[] | string | undefined, newChildren: VNode[] | string | undefined, context?: Record<string, unknown>, refs?: VDomRefs): void;
+/**
+ * Patch a node using keys for node matching.
+ * @param dom
+ * @param oldVNode
+ * @param newVNode
+ * @param context
+ * @param refs
+ * @returns
+ */
+export declare function patch(dom: Node, oldVNode: VNode | string | null, newVNode: VNode | string | null, context?: Record<string, unknown>, refs?: VDomRefs): Node;
+/**
+ * Virtual DOM renderer.
+ * @param root The root element to render into.
+ * @param vnodeOrArray The virtual node or array of virtual nodes to render.
+ * @param context The context to use for rendering.
+ * @param refs The refs to use for rendering.
+ */
+export declare function vdomRenderer(root: ShadowRoot, vnodeOrArray: VNode | VNode[], context?: Record<string, unknown>, refs?: VDomRefs): void;

package/dist/runtime/vdom.d.ts

@@ -1,142 +1,18 @@
 /**
  * vdom.ts
- * Lightweight, strongly typed, functional virtual DOM renderer for custom elements.
- * Features: keyed diffing, incremental patching, focus/caret preservation, event delegation, SSR-friendly, no dependencies.
- */
-import type { VNode, VDomRefs } from './types';
-type PropsMap = Record<string, unknown>;
-type DirectiveSpec = {
-    value: unknown;
-    modifiers: string[];
-    arg?: string;
-};
-type VNodePropBag = {
-    props?: PropsMap;
-    attrs?: PropsMap;
-    directives?: Record<string, DirectiveSpec>;
-    isCustomElement?: boolean;
-    [k: string]: unknown;
-};
-/**
- * Recursively clean up refs and event listeners for all descendants of a node
- * @param node The node to clean up.
- * @param refs The refs to clean up.
- * @returns
- */
-export declare function cleanupRefs(node: Node, refs?: VDomRefs): void;
-/**
- * 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>;
-};
-/**
- * Assign unique keys to VNodes for efficient rendering
- * @param nodeOrNodes
- * @param baseKey
- * @returns
- */
-export declare function assignKeysDeep(nodeOrNodes: VNode | VNode[], baseKey: string): VNode | VNode[];
-/**
- * Patch props on an element.
- * Only update changed props, remove old, add new.
- * @param el
- * @param oldProps
- * @param newProps
- * @param context
- */
-export declare function patchProps(el: HTMLElement, oldProps: VNodePropBag, newProps: VNodePropBag, context?: Record<string, unknown>): void;
-/**
- * Create a DOM element from a VNode.
- * @param vnode
- * @param context
- * @param refs
- * @returns
- */
-export declare function createElement(vnode: VNode | string, context?: Record<string, unknown>, refs?: VDomRefs, parentNamespace?: string | null): Node;
-/**
- * Patch children using keys for node matching.
- * @param parent
- * @param oldChildren
- * @param newChildren
- * @param context
- * @param refs
- * @returns
- */
-export declare function patchChildren(parent: HTMLElement, oldChildren: VNode[] | string | undefined, newChildren: VNode[] | string | undefined, context?: Record<string, unknown>, refs?: VDomRefs): void;
-/**
- * Patch a node using keys for node matching.
- * @param dom
- * @param oldVNode
- * @param newVNode
- * @param context
- * @param refs
- * @returns
- */
-export declare function patch(dom: Node, oldVNode: VNode | string | null, newVNode: VNode | string | null, context?: Record<string, unknown>, refs?: VDomRefs): Node;
-/**
- * Virtual DOM renderer.
- * @param root The root element to render into.
- * @param vnodeOrArray The virtual node or array of virtual nodes to render.
- * @param context The context to use for rendering.
- * @param refs The refs to use for rendering.
- */
-export declare function vdomRenderer(root: ShadowRoot, vnodeOrArray: VNode | VNode[], context?: Record<string, unknown>, refs?: VDomRefs): void;
-export {};
+ *
+ * Barrel re-export module for the virtual DOM implementation.
+ * The actual code lives in the focused sub-modules:
+ *
+ * | Module               | Responsibilities                                       |
+ * |----------------------|--------------------------------------------------------|
+ * | vdom-helpers.ts      | Private utilities and shared internal types            |
+ * | vdom-directives.ts   | processModelDirective and all process*Directive funcs  |
+ * | vdom-patch.ts        | assignKeysDeep, patchProps, createElement, patch, etc. |
+ * | vdom-ssr.ts          | renderToString (server-side rendering)                 |
+ *
+ * Import directly from these focused modules for tree-shaking.
+ * This file is kept for backwards compatibility.
+ */
+export { processModelDirective, processBindDirective, processShowDirective, processClassDirective, processStyleDirective, processRefDirective, processDirectives, } from "./vdom-directives";
+export { cleanupRefs, assignKeysDeep, patchProps, createElement, patchChildren, patch, vdomRenderer, } from "./vdom-patch";