@lark.js/mvc 0.0.9 → 0.0.11

package/dist/index.d.ts

@@ -1,3 +1,88 @@
+/**
+ * Lark framework constants.
+ */
+/** Internal splitter character (U+001E Record Separator, invisible, used as namespace separator).
+ * Uses String.fromCharCode to survive bundlers that strip control-char literals. */
+declare const SPLITTER: string;
+declare const RouterEvents: {
+    CHANGE: string;
+    CHANGED: string;
+    PAGE_UNLOAD: string;
+};
+/** Attribute name: v-lark */
+declare const LARK_VIEW = "v-lark";
+/** View event method regex: e.g. "app\x1eclickHandler(click)" or "clickHandler()"
+ * Group 1: optional frame ID (before SPLITTER)
+ * Group 2: handler name
+ * Group 3: params string
+ */
+declare const EVENT_METHOD_REGEXP: RegExp;
+/** View event method name regex: e.g. "name<click,mousedown>" or "$selector<click>" */
+declare const VIEW_EVENT_METHOD_REGEXP: RegExp;
+/** Tag name regexp for I_GetNode */
+declare const TAG_NAME_REGEXP: RegExp;
+/** Async task break time (ms) */
+declare const CALL_BREAK_TIME = 48;
+/** Increment global counter and return new value */
+declare function nextCounter(): number;
+
+/**
+ * Dynamically inject CSS styles into the document head.
+ * Returns a cleanup function to remove the injected styles.
+ *
+ * @param styleIdOrPairs - Style ID string or array of [id, content] pairs
+ * @param css - CSS content string (only used when first arg is string)
+ * @returns Cleanup function to remove the styles
+ */
+declare function applyStyle(styleIdOrPairs: string | string[], css?: string): () => void;
+
+/**
+ * Mark/Unmark: signature-based lifecycle tracking for async callbacks.
+ *
+ * `mark(host, key)` returns a validity checker. The checker returns `false`
+ * once the host is unmarked (e.g. when a view re-renders or is destroyed),
+ * so stale async callbacks can short-circuit and skip work.
+ *
+ * State is stored in a module-level WeakMap, not on the host object, so
+ * `mark/unmark` never pollutes user objects with magic keys, never breaks
+ * on `Object.freeze`-ed inputs, and never shows up in debug snapshots.
+ */
+/**
+ * Create a mark for tracking async callback validity.
+ * Returns a function that returns true while the mark is still valid.
+ *
+ * @param host - Object to associate the mark with (typically a view)
+ * @param key  - Key to track (typically "render" or a specific async-op identifier)
+ */
+declare function mark(host: object, key: string): () => boolean;
+/**
+ * Clear all marks for a host object, invalidating every existing checker.
+ * Called when a view re-renders or is destroyed.
+ *
+ * @param host - Object whose marks should be invalidated
+ */
+declare function unmark(host: object): void;
+
+/**
+ * Safeguard: Proxy-based debug protection for data objects.
+ *
+ * In DEBUG mode, wraps data objects with Proxy to:
+ * 1. Warn when data is read from a different page than where it was set
+ * 2. Prevent direct mutation (forces use of State.set/digest)
+ * 3. Track access patterns for debugging
+ */
+/**
+ * Wrap data with a Proxy for debug-mode protection.
+ * Only active when window.__lark_Debug is true and Proxy is available.
+ *
+ * @param data - Data to wrap
+ * @param getter - Optional callback when properties are read
+ * @param setter - Optional callback when properties are written
+ * @param isRoot - Whether this is the root data object
+ * @returns Proxied data or original data if debug mode is off
+ */
+declare function safeguard<T>(data: T, getter?: ((key: string) => void) | null, setter?: ((path: string, value: unknown) => void) | null, isRoot?: boolean): T;
+
 /**
  * Multi-cast event emitter class.
  *
@@ -59,8 +144,6 @@ declare class View implements ViewInterface {
     observedStateKeys?: string[];
     /** Resource map */
     resources: Record<string, ViewResourceEntry>;
-    /** Assign method reference */
-    assignMethod?: AnyFunc;
     /** Whether endUpdate pending */
     endUpdatePending?: number;
     /** Internal event storage */
@@ -303,15 +386,15 @@ declare class Frame extends EventEmitter implements FrameInterface {
     /**
      * Unmount a child frame.
      */
-    unmountFrame(id?: string, _inner?: boolean): void;
+    unmountFrame(id?: string): void;
     /**
      * Mount all views in a zone.
      */
-    mountZone(zoneId?: string, _inner?: boolean): void;
+    mountZone(zoneId?: string): void;
     /**
      * Unmount all views in a zone.
      */
-    unmountZone(zoneId?: string, _inner?: boolean): void;
+    unmountZone(zoneId?: string): void;
     /**
      * Get all child frame IDs.
      */
@@ -363,15 +446,6 @@ declare class Frame extends EventEmitter implements FrameInterface {
      * `Framework.boot()` is the canonical caller; user code rarely needs this.
      */
     static createRoot(rootId?: string): Frame;
-    /**
-     * @deprecated Use `Frame.getRoot()` for read-only access or
-     * `Frame.createRoot(id)` to create the root explicitly. The single-method
-     * `root()` blurred the distinction and was a common source of bugs in
-     * Micro-Frontend hosts.
-     *
-     * Kept for backward compatibility — behavior unchanged.
-     */
-    static root(rootId?: string): Frame;
     /** Bind event listener (static) */
     static on(event: string, handler: AnyFunc): typeof Frame;
     /** Unbind event listener (static) */
@@ -380,75 +454,6 @@ declare class Frame extends EventEmitter implements FrameInterface {
     static fire(event: string, data?: Record<string, unknown>): void;
 }
 
-/**
- * Cache class with LFU-style eviction.
- * Keys are prefixed with SPLITTER for namespace isolation.
- *
- * @example
- * const cache = new Cache({ maxSize: 20, bufferSize: 5 });
- * cache.set('user', { name: 'Alice' });
- * const user = cache.get('user');
- * cache.has('user'); // true
- * cache.del('user');
- */
-declare class Cache<T = unknown> implements CacheInterface<T> {
-    /** Cache entries array */
-    private entries;
-    /** Fast lookup: prefixed key -> entry */
-    private lookup;
-    /** Buffer size for eviction */
-    private readonly bufferSize;
-    /** Maximum cache size */
-    private readonly maxSize;
-    /** Total capacity (maxSize + bufferSize) */
-    private readonly capacity;
-    /** Callback when entry is removed */
-    private readonly onRemove?;
-    /** Sort comparator */
-    private readonly comparator;
-    constructor(options?: CacheOptions<T>);
-    /** Prefix a key with SPLITTER for namespace isolation */
-    private prefixKey;
-    /**
-     * Get a cached value by key.
-     * Updates frequency and timestamp for cache sorting.
-     */
-    get(key: string): T | undefined;
-    /**
-     * Iterate all cached values.
-     */
-    forEach(callback: (value: T | undefined) => void): void;
-    /**
-     * Set or update a cached value.
-     * If key already exists, updates value and increments frequency.
-     * If cache exceeds capacity, triggers eviction.
-     */
-    set(key: string, value: T): void;
-    /**
-     * Delete a cached entry. Removes it immediately from both the lookup map
-     * and the entries array so the GC can reclaim the value without waiting
-     * for the next eviction sweep.
-     */
-    del(key: string): void;
-    /**
-     * Check if a key exists in cache.
-     */
-    has(key: string): boolean;
-    /** Get current cache size */
-    get size(): number;
-    /** Clear all entries */
-    clear(): void;
-    /**
-     * Evict the `bufferSize` worst entries from the cache.
-     *
-     * Uses single-pass partial selection (O(n·k)) instead of sorting the entire
-     * `entries` array (O(n log n)). For the typical `bufferSize = 5` this is
-     * effectively a linear scan with at most 5 in-bucket comparisons per
-     * iteration — and it avoids mutating the rest of `entries`.
-     */
-    private evictEntries;
-}
-
 /**
  * Lark framework type definitions.
  * All shared types are defined here to eliminate type cheats across modules.
@@ -660,6 +665,68 @@ interface DomRef {
  * Comment), so the child slots are typed as ChildNode.
  */
 type DomOp = [1, Element, ChildNode] | [2, Element, ChildNode] | [4, Element, ChildNode, ChildNode] | [8, Element, ChildNode, ChildNode];
+/**
+ * Virtual DOM node. Produced by `vdomCreate`, consumed by the VDOM diff engine.
+ *
+ * Property semantics:
+ * - Text nodes: tag = 0 (V_TEXT_NODE), html = text content
+ * - Element nodes: tag = string, attrs = serialized opening tag, children = child VDomNodes
+ * - Raw HTML nodes: tag = SPLITTER (\x1e), html = raw HTML string
+ * - Self-closing: selfClose = true (children param was 1)
+ */
+interface VDomNode {
+    /** Tag name for elements, 0 (V_TEXT_NODE) for text, SPLITTER for raw HTML */
+    tag: string | number;
+    /** Inner HTML (serialized children for elements, text content for text nodes) */
+    html: string;
+    /** Serialized opening tag with attributes, e.g. '<div class="row"' */
+    attrs?: string;
+    /** Attribute key-value map */
+    attrsMap?: Record<string, unknown>;
+    /** Attribute names that are set as DOM properties (not attributes) */
+    attrsSpecials?: Record<string, string>;
+    /** Original specials argument before defaulting (for change detection) */
+    hasSpecials?: Record<string, string> | undefined;
+    /** Child VDomNode array (undefined for text/raw/self-closing) */
+    children?: VDomNode[] | undefined;
+    /** Diff key: from id, _, #, or v-lark path */
+    compareKey?: string | undefined;
+    /** Keyed children count map (compareKey -> count) */
+    reused?: Record<string, number> | undefined;
+    /** Total count of keyed children */
+    reusedTotal?: number;
+    /** Sub-view references: [viewPath, owner, uri, params] tuples */
+    views?: [string, string, string, Record<string, string>][] | undefined;
+    /** Whether self-closing (children param was literal 1) */
+    selfClose?: boolean;
+    /** Sub-view path if this node hosts a v-lark view, otherwise falsy */
+    isLarkView?: string | undefined;
+}
+/**
+ * VDOM diff operation tracker. Parallel to DomRef but for the VDOM pipeline.
+ */
+interface VDomRef {
+    /** View ID (for placeholder replacement) */
+    viewId: string;
+    /** Sub-views that need re-rendering after diff */
+    viewRenders: ViewInterface[];
+    /** Deferred DOM property assignments: [element, propName, value][] */
+    nodeProps: [Element, string, unknown][];
+    /** Pending async operation count */
+    asyncCount: number;
+    /** Whether the DOM actually changed */
+    changed: number;
+    /** DOM mutation operations (same format as DomOp) */
+    domOps: DomOp[];
+}
+/** VDOM node creation function signature (vdomCreate) */
+type VDomCreateFn = (tag: string | number, props?: Record<string, unknown> | number | null, children?: VDomNode[] | number | null, specials?: Record<string, string>) => VDomNode;
+/**
+ * VDOM template function signature.
+ * The compiled template imports vdomCreate via ES module import and
+ * takes only (data, viewId, refData). Extra arguments are ignored.
+ */
+type VDomTemplate = (data: unknown, viewId: string, refData: unknown) => VDomNode;
 interface FrameInvokeEntry {
     /** Method name */
     name: string;
@@ -853,7 +920,7 @@ interface ViewInterface extends EventEmitterInterface<ViewInterface> {
      * View template function. Receives data + viewId + refData and a set of
      * encoder helpers wired in by the Updater, and returns the rendered HTML.
      */
-    template?: ViewTemplate;
+    template?: ViewTemplate | VDomTemplate;
     /**
      * Mixin object array for extending view functionality.
      * Framework merges properties and methods from mixins into view prototype.
@@ -872,10 +939,10 @@ interface ViewInterface extends EventEmitterInterface<ViewInterface> {
     eventObjectMap: Record<string, number>;
     /** Global event list */
     globalEventList: ViewGlobalEventEntry[];
-    /** Assign method reference */
-    assignMethod?: AnyFunc;
     /** Whether endUpdate has been called (1 = pending) */
     endUpdatePending?: number;
+    /** Last rendered VDOM tree (only used when virtualDom is enabled) */
+    vdom?: VDomNode;
     /** Render method (wrapped) */
     render(): void;
     /**
@@ -1022,18 +1089,17 @@ interface FrameInterface extends EventEmitterInterface<FrameInterface> {
      * Unmount child Frame from specified DOM node.
      * @param id DOM node ID, defaults to current Frame if omitted
      */
-    unmountFrame: (id?: string, inner?: boolean) => void;
+    unmountFrame: (id?: string) => void;
     /**
      * Render all child views under specified node (scans v-lark attributes and mounts).
      * @param zoneId DOM node ID, defaults to current Frame
-     * @param inner Whether this is an internal framework call
      */
-    mountZone: (zoneId?: string, inner?: boolean) => void;
+    mountZone: (zoneId?: string) => void;
     /**
      * Unmount all child views under specified node.
      * @param zoneId DOM node ID, defaults to current Frame
      */
-    unmountZone: (zoneId?: string, inner?: boolean) => void;
+    unmountZone: (zoneId?: string) => void;
     /**
      * Get ancestor Frame, defaults to parent Frame (level=1).
      * @param level Levels to traverse upward, defaults to 1
@@ -1254,24 +1320,6 @@ interface ServiceOptions {
     /** POST data */
     data?: unknown;
 }
-interface PayloadEntry {
-    /** Payload data */
-    data: Record<string, unknown>;
-}
-interface ServiceEntry {
-    /** Service ID */
-    id: string;
-    /** Service URL */
-    url: string;
-    /** Cache time in ms, 0 = no cache */
-    cacheTime: number;
-    /** Payload instance */
-    payload?: PayloadEntry;
-    /** Whether loading */
-    loading?: boolean;
-    /** Error info */
-    error?: Error;
-}
 /** Pending cache entry for deduplication (internal to Service) */
 interface PendingCacheEntry extends Array<unknown> {
     /** Reference to the pending Payload entity */
@@ -1321,103 +1369,6 @@ interface ServiceMetaEntry {
     /** Additional properties */
     [key: string]: unknown;
 }
-interface ServiceInternals {
-    metaList: Record<string, ServiceMetaEntry>;
-    payloadCache: CacheInterface<PayloadInterface>;
-    pendingCacheKeys: Record<string, PendingCacheEntry>;
-    syncFn: (payload: PayloadInterface, callback: () => void) => void;
-    staticEmitter: EventEmitterInterface;
-}
-interface ServiceInterface {
-    id: string;
-    destroyed: number;
-    busy: number;
-    taskQueue: AnyFunc[];
-    prevArgs: unknown[];
-    emitter: EventEmitterInterface;
-    internals: ServiceInternals;
-    /**
-     * Send all requests in parallel, execute done callback when all requests complete (success or failure).
-     * If endpoint specifies cache and cache is valid, uses cached data directly.
-     * @param metaList Endpoint name string, params object, or array of them
-     * @param done Callback when all requests complete, first param is error array, followed by each endpoint's Payload
-     */
-    all(metaList: string | Record<string, unknown> | (string | Record<string, unknown>)[], done: AnyFunc): ServiceInterface;
-    /**
-     * Execute callback after each request succeeds, callback may be called multiple times.
-     * @param metaList Endpoint name string, params object, or array of them
-     * @param done Callback
-     */
-    one(attrs: string | Record<string, unknown> | (string | Record<string, unknown>)[], done: AnyFunc): ServiceInterface;
-    /**
-     * Similar to all, but always skips cache and forces actual requests.
-     * @param metaList Endpoint name string, params object, or array of them
-     * @param done Callback
-     */
-    save(metaList: string | Record<string, unknown> | (string | Record<string, unknown>)[], done: AnyFunc): ServiceInterface;
-    /**
-     * Queue task for execution, executes next task after previous all/one/save task completes, similar to Promise chain.
-     * @param callback Callback invoked after task completes
-     */
-    enqueue(callback: AnyFunc): ServiceInterface;
-    /**
-     * Dequeue and execute next task in queue.
-     */
-    dequeue(...args: unknown[]): void;
-    /**
-     * Destroy current Service instance, cannot send new requests or invoke callbacks after destruction.
-     */
-    destroy(): void;
-    /**
-     * Add endpoint metadata, register one or more API endpoints.
-     * @param metaList Endpoint metadata array, or single metadata object
-     */
-    add(attrs: ServiceMetaEntry | ServiceMetaEntry[]): void;
-    /**
-     * Get metadata object.
-     * @param attrs Endpoint metadata object or name string
-     */
-    meta(attrs: string | Record<string, unknown>): ServiceMetaEntry;
-    /**
-     * Create Payload object from endpoint metadata.
-     * @param meta Endpoint metadata object or name string
-     */
-    create(meta: Record<string, unknown>): PayloadInterface;
-    /**
-     * Get or create Payload object from cache.
-     * @param meta Endpoint metadata object
-     * @param createNew Whether to create new Payload object; if false, prioritizes getting from cache
-     */
-    get(meta: Record<string, unknown>, createNew?: boolean): {
-        entity: PayloadInterface;
-        needsUpdate: boolean;
-    };
-    /**
-     * Get Payload object from cache, returns undefined if cache doesn't exist or has expired.
-     * @param meta Endpoint metadata object
-     */
-    cached(meta: Record<string, unknown>): PayloadInterface | undefined;
-    /**
-     * Clear cached data for specified endpoint.
-     * @param names Comma-separated endpoint name string or string array
-     */
-    clear(names: string | string[]): void;
-    /**
-     * Inherit to create new Service subclass, bind custom data sync function.
-     * @param sync Method to sync data, typically exchanges data with server
-     * @param cacheMax Maximum cache entries
-     * @param cacheBuffer Cache buffer size
-     */
-    extend(newSyncFn: (payload: PayloadInterface, callback: () => void) => void, newCacheMax?: number, newCacheBuffer?: number): ServiceInterface;
-    /**
-     * Triggered before endpoint sends request.
-     */
-    onBegin?: (e?: ServiceEvent) => void;
-    /**
-     * Triggered when endpoint request completes, whether success or failure.
-     */
-    onEnd?: (e?: ServiceEvent) => void;
-}
 /** Cache info attached to Payload entity */
 interface ServiceCacheInfo {
     /** Endpoint name */
@@ -1633,7 +1584,7 @@ interface FrameworkInterface {
 }
 /**
  * Framework configuration interface, global config passed to app during `Framework.boot()`.
- * All config items can be accessed at runtime via `Framework.config('key')`.
+ * All config items can be accessed at runtime via `Framework.getConfig('key')`.
  */
 interface FrameworkConfig {
     /**
@@ -1715,7 +1666,7 @@ interface FrameworkConfig {
      */
     crossConfigs?: CrossSiteConfig[];
     /** Default false. */
-    virtualDOM?: boolean;
+    virtualDom?: boolean;
     /** Dynamic config access, custom config items */
     [key: string]: unknown;
 }
@@ -1772,153 +1723,80 @@ interface CompileOptions {
     globalVars?: string[];
     /** File path for debug error messages (default: undefined) */
     file?: string;
+    /** Generate VDOM output instead of HTML string (default: false) */
+    virtualDom?: boolean;
+    /** Use SWC instead of Babel for parsing (default: false) */
+    useSwc?: boolean;
 }
 
 /**
- * Lark framework utility functions.
- */
-
-/** Check if value is a plain object (not null, not array, typeof object) */
-declare function isPlainObject(value: unknown): value is Record<string, unknown>;
-/** Check if value is primitive or function (not a complex object) */
-declare function isPrimitiveOrFunc(value: unknown): boolean;
-/** Check if value is primitive (not object, not function) */
-declare function isPrimitive(value: unknown): boolean;
-declare function generateId(prefix?: string): string;
-/** Sync local counter with global counter */
-declare function syncCounter(val: number): void;
-declare function noop(): void;
-/** Safe hasOwnProperty check */
-declare function hasOwnProperty<T extends object>(owner: T | undefined | null, prop: PropertyKey): boolean;
-/** Get object keys (own enumerable) */
-declare function keys<T extends object>(obj: T): string[];
-/** Assign properties from sources to target (like Object.assign but safer) */
-declare function assign<T extends object>(target: T, ...sources: Partial<T>[]): T;
-/**
- * Execute functions in try-catch, ignoring errors.
- * Returns the result of the last successfully executed function.
- */
-declare function funcWithTry(fns: AnyFunc | AnyFunc[], args: unknown[], context: unknown, configError?: (e: unknown) => void): unknown;
-/**
- * Set newData into oldData, tracking changed keys.
- * Returns whether any value changed.
- */
-declare function setData(newData: Record<string, unknown>, oldData: Record<string, unknown>, changedKeys: Set<string>, excludes: ReadonlySet<string>): boolean;
-declare function translateData(data: object, value: unknown): unknown;
-/** Get element by ID, or return the element itself if already an element */
-declare function getById(id: string | Element | null): Element | null;
-/** Get attribute from element safely */
-declare function getAttribute(element: Element, attr: string): string;
-/** Ensure element has an ID, generating one if missing. Returns the ID. */
-declare function ensureElementId(element: HTMLElement): string;
-/**
- * Check if node A is inside node B (or is the same node).
- * Uses compareDocumentPosition for efficiency.
- */
-declare function nodeInside(a: string | HTMLElement, b: string | HTMLElement): boolean;
-/**
- * Parse URI string into path and params object.
- * e.g. "/xxx/?a=b&c=d" => { path: "/xxx/", params: { a: "b", c: "d" } }
- *
- * The accumulator is function-local, so nested / re-entrant calls
- * (e.g. invoking `parseUri` again inside a replace callback) are safe.
- */
-declare function parseUri(uri: string): ParsedUri;
-/**
- * Convert path and params to URI string.
- * e.g. toUri("/xxx/", { a: "b", c: "d" }) => "/xxx/?a=b&c=d"
- */
-declare function toUri(path: string, params: Record<string, unknown>, keepEmpty?: ReadonlySet<string>): string;
-/**
- * Convert array to map/hash object.
- * For simple arrays, counts occurrences.
- * For object arrays, uses specified key as map key.
- */
-declare function toMap<T>(list: T[] | null | undefined, key?: keyof T): Record<string, T | number>;
-/** Get current timestamp */
-declare function now(): number;
-
-/** Internal splitter character (U+001E Record Separator, invisible, used as namespace separator).
- * Uses String.fromCharCode to survive bundlers that strip control-char literals. */
-declare const SPLITTER: string;
-declare const RouterEvents: {
-    CHANGE: string;
-    CHANGED: string;
-    PAGE_UNLOAD: string;
-};
-/** Attribute name: v-lark */
-declare const LARK_VIEW = "v-lark";
-/** View event method regex: e.g. "app\x1eclickHandler(click)" or "clickHandler()"
- * Group 1: optional frame ID (before SPLITTER)
- * Group 2: handler name
- * Group 3: params string
- */
-declare const EVENT_METHOD_REGEXP: RegExp;
-/** View event method name regex: e.g. "name<click,mousedown>" or "$selector<click>" */
-declare const VIEW_EVENT_METHOD_REGEXP: RegExp;
-/** Tag name regexp for I_GetNode */
-declare const TAG_NAME_REGEXP: RegExp;
-/** Async task break time (ms) */
-declare const CALL_BREAK_TIME = 48;
-/** Increment global counter and return new value */
-declare function nextCounter(): number;
-
-/**
- * Dynamically inject CSS styles into the document head.
- * Returns a cleanup function to remove the injected styles.
- *
- * @param styleIdOrPairs - Style ID string or array of [id, content] pairs
- * @param css - CSS content string (only used when first arg is string)
- * @returns Cleanup function to remove the styles
- */
-declare function applyStyle(styleIdOrPairs: string | string[], css?: string): () => void;
-
-/**
- * Mark/Unmark: signature-based lifecycle tracking for async callbacks.
- *
- * `mark(host, key)` returns a validity checker. The checker returns `false`
- * once the host is unmarked (e.g. when a view re-renders or is destroyed),
- * so stale async callbacks can short-circuit and skip work.
- *
- * State is stored in a module-level WeakMap, not on the host object, so
- * `mark/unmark` never pollutes user objects with magic keys, never breaks
- * on `Object.freeze`-ed inputs, and never shows up in debug snapshots.
- */
-/**
- * Create a mark for tracking async callback validity.
- * Returns a function that returns true while the mark is still valid.
- *
- * @param host - Object to associate the mark with (typically a view)
- * @param key  - Key to track (typically "render" or a specific async-op identifier)
- */
-declare function mark(host: object, key: string): () => boolean;
-/**
- * Clear all marks for a host object, invalidating every existing checker.
- * Called when a view re-renders or is destroyed.
- *
- * @param host - Object whose marks should be invalidated
- */
-declare function unmark(host: object): void;
-
-/**
- * Safeguard: Proxy-based debug protection for data objects.
- *
- * In DEBUG mode, wraps data objects with Proxy to:
- * 1. Warn when data is read from a different page than where it was set
- * 2. Prevent direct mutation (forces use of State.set/digest)
- * 3. Track access patterns for debugging
- */
-/**
- * Wrap data with a Proxy for debug-mode protection.
- * Only active when window.__lark_Debug is true and Proxy is available.
+ * Cache class with LFU-style eviction.
+ * Keys are prefixed with SPLITTER for namespace isolation.
  *
- * @param data - Data to wrap
- * @param getter - Optional callback when properties are read
- * @param setter - Optional callback when properties are written
- * @param isRoot - Whether this is the root data object
- * @returns Proxied data or original data if debug mode is off
+ * @example
+ * const cache = new Cache({ maxSize: 20, bufferSize: 5 });
+ * cache.set('user', { name: 'Alice' });
+ * const user = cache.get('user');
+ * cache.has('user'); // true
+ * cache.del('user');
  */
-declare function safeguard<T>(data: T, getter?: ((key: string) => void) | null, setter?: ((path: string, value: unknown) => void) | null, isRoot?: boolean): T;
+declare class Cache<T = unknown> implements CacheInterface<T> {
+    /** Cache entries array */
+    private entries;
+    /** Fast lookup: prefixed key -> entry */
+    private lookup;
+    /** Buffer size for eviction */
+    private readonly bufferSize;
+    /** Maximum cache size */
+    private readonly maxSize;
+    /** Total capacity (maxSize + bufferSize) */
+    private readonly capacity;
+    /** Callback when entry is removed */
+    private readonly onRemove?;
+    /** Sort comparator */
+    private readonly comparator;
+    constructor(options?: CacheOptions<T>);
+    /** Prefix a key with SPLITTER for namespace isolation */
+    private prefixKey;
+    /**
+     * Get a cached value by key.
+     * Updates frequency and timestamp for cache sorting.
+     */
+    get(key: string): T | undefined;
+    /**
+     * Iterate all cached values.
+     */
+    forEach(callback: (value: T | undefined) => void): void;
+    /**
+     * Set or update a cached value.
+     * If key already exists, updates value and increments frequency.
+     * If cache exceeds capacity, triggers eviction.
+     */
+    set(key: string, value: T): void;
+    /**
+     * Delete a cached entry. Removes it immediately from both the lookup map
+     * and the entries array so the GC can reclaim the value without waiting
+     * for the next eviction sweep.
+     */
+    del(key: string): void;
+    /**
+     * Check if a key exists in cache.
+     */
+    has(key: string): boolean;
+    /** Get current cache size */
+    get size(): number;
+    /** Clear all entries */
+    clear(): void;
+    /**
+     * Evict the `bufferSize` worst entries from the cache.
+     *
+     * Uses single-pass partial selection (O(n·k)) instead of sorting the entire
+     * `entries` array (O(n log n)). For the typical `bufferSize = 5` this is
+     * effectively a linear scan with at most 5 in-bucket comparisons per
+     * iteration — and it avoids mutating the rest of `entries`.
+     */
+    private evictEntries;
+}
 
 /** Mark framework as booted (called from Framework.boot) */
 declare function markBooted(): void;
@@ -1992,59 +1870,6 @@ declare function resetProjectsMap(): void;
  */
 declare const CrossSite: typeof View;
 
-/**
- * Unmount frames within a DOM node.
- */
-declare function domUnmountFrames(frame: FrameInterface, node: ChildNode): void;
-/**
- * Parse HTML string into a DOM element.
- * Handles special elements (table, SVG, MathML) with wrapper elements.
- */
-declare function domGetNode(html: string, refNode: Element): Element;
-/**
- * Get compare key for a DOM node (for keyed diff).
- * Uses id or v-lark path.
- */
-declare function domGetCompareKey(node: ChildNode): string | undefined;
-/**
- * Special diff for form elements (value, checked, selected).
- * Form elements carry state on the DOM node (e.g. `input.value`) that isn't
- * reflected in attributes, so we have to sync those properties separately.
- */
-declare function domSpecialDiff(oldNode: ChildNode, newNode: ChildNode): number;
-/**
- * Set attributes from new element onto old element, tracking changes in ref.
- */
-declare function domSetAttributes(oldNode: Element, newNode: Element, ref: DomRef, keepId?: boolean): void;
-/**
- * Set child nodes from new parent onto old parent using keyed diff algorithm.
- */
-declare function domSetChildNodes(oldParent: Element, newParent: Element, ref: DomRef, frame: FrameInterface, keys_?: ReadonlySet<string>): void;
-/**
- * Diff two DOM nodes and apply changes.
- */
-declare function domSetNode(oldNode: ChildNode, newNode: ChildNode, oldParent: Element, ref: DomRef, frame: FrameInterface, keys_?: ReadonlySet<string>): void;
-/**
- * Create an empty DomRef for tracking diff operations.
- */
-declare function createDomRef(): DomRef;
-/**
- * Apply DOM diff operations to the DOM.
- */
-declare function applyDomOps(ops: DomOp[]): void;
-/**
- * Apply ID updates from DOM diff.
- */
-declare function applyIdUpdates(updates: [Element, string][]): void;
-/** Encode value for safe HTML output */
-declare function encodeHTML(v: unknown): string;
-/** Safe string conversion */
-declare function encodeSafe(v: unknown): string;
-/** URI-encode a value with extra character encoding */
-declare function encodeURIExtra(v: unknown): string;
-/** Quote-encode a value for attribute use */
-declare function encodeQ(v: unknown): string;
-
 /**
  * Updater class for view data binding.
  * Manages view-local data with change detection and DOM diff triggering.
@@ -2071,6 +1896,8 @@ declare class Updater implements UpdaterInterface {
     private version;
     /** Snapshot of `version` taken by `snapshot()`, used by `altered()`. */
     private snapshotVersion;
+    /** Last rendered VDOM tree (only used when virtualDom is enabled) */
+    private vdom?;
     constructor(viewId: string);
     /**
      * Get data by key.
@@ -2112,7 +1939,7 @@ declare class Updater implements UpdaterInterface {
      * Translate a refData reference back to its original value.
      *
      * The ref protocol is `SPLITTER` + ascii decimal digits — the exact format
-     * emitted by `updaterRef`. We require that exact shape so a user-supplied
+     * emitted by `refFn`. We require that exact shape so a user-supplied
      * string that merely begins with SPLITTER is never accidentally resolved
      * (or mishandled as a "missing ref").
      */
@@ -2133,6 +1960,21 @@ declare class Updater implements UpdaterInterface {
     getChangedKeys(): ReadonlySet<string>;
 }
 
+/**
+ * Create a virtual DOM node.
+ *
+ * Text node: `vdomCreate(0, 'text content')`
+ * Element: `vdomCreate('div', { class: 'row' }, [child1, child2])`
+ * Self-closing: `vdomCreate('br', null, 1)`
+ * Raw HTML: `vdomCreate(0, '<b>bold</b>', 1)` (children truthy → raw HTML node)
+ * Root: `vdomCreate(viewId, 0, [children])`
+ */
+declare function vdomCreate(tag: string | number, props?: Record<string, unknown> | string | number | null, children?: VDomNode[] | string | number | null, specials?: Record<string, string>): VDomNode;
+/**
+ * Create an empty VDomRef for tracking diff operations.
+ */
+declare function createVDomRef(viewId: string): VDomRef;
+
 /**
  * Payload wraps API response data with convenient access methods.
  */
@@ -2427,92 +2269,6 @@ declare function create<T>(name: string, creator: StateCreator<T>): StoreApi<T>;
  * bindStore(this, useCountStore, (s) => ({ count: s.count }));
  * ```
  */
-declare function bindStore<T extends Record<string, unknown>>(view: unknown, store: StoreApi<T>, selector?: (state: T) => Record<string, unknown>): () => void;
-/**
- * @deprecated Use `create()` instead. This is a temporary alias.
- */
-declare const defineStore: typeof create;
-
-/** Serialized view info attached to a frame node */
-interface SerializedViewInfo {
-    /** View ID (same as frame ID) */
-    id: string;
-    /** Whether the view has rendered at least once */
-    rendered: boolean;
-    /** View signature (> 0 = active) */
-    signature: number;
-    /** Observed state keys */
-    observedStateKeys: string[] | null;
-    /** Location observation config */
-    locationObserved: {
-        flag: number;
-        keys: string[];
-        observePath: boolean;
-    };
-    /** Whether view has a template function */
-    hasTemplate: boolean;
-    /** Delegated event types (keys from $evtObjMap) */
-    eventMethodKeys: string[];
-    /** Captured resource keys */
-    resourceKeys: string[];
-    /** Whether view exposes an assign method (supports CrossSite reuse) */
-    hasAssign: boolean;
-    /** Updater refData snapshot (shallow copy of current data) */
-    updaterData: Record<string, unknown> | null;
-}
-/** A single node in the serialized frame tree */
-interface SerializedFrameNode {
-    /** Frame ID (same as owner DOM element ID) */
-    id: string;
-    /** Parent frame ID (null for root) */
-    parentId: string | null;
-    /** View path (v-lark attribute value) */
-    viewPath: string | null;
-    /** Number of child frames */
-    childrenCount: number;
-    /** Number of children that have fired 'created' */
-    readyCount: number;
-    /** Whether children have been created */
-    childrenCreated: number;
-    /** Whether children are in alter state */
-    childrenAlter: number;
-    /** Whether this frame is destroyed */
-    destroyed: number;
-    /** Serialized view info (null if no view mounted) */
-    view: SerializedViewInfo | null;
-    /** Child frame nodes */
-    children: SerializedFrameNode[];
-}
-/** Top-level serialized frame tree */
-interface SerializedFrameTree {
-    /** Root frame node */
-    root: SerializedFrameNode | null;
-    /** Total frame count */
-    totalFrames: number;
-    /** Timestamp of serialization */
-    timestamp: number;
-    /** Root element ID */
-    rootId: string;
-}
-declare const FrameVisualBridge: {
-    MSG_PING: string;
-    MSG_PONG: string;
-    MSG_REQUEST_TREE: string;
-    MSG_TREE: string;
-    MSG_TREE_DELTA: string;
-};
-/**
- * Serialize the entire Frame tree starting from root.
- * Returns an empty snapshot if the app hasn't booted yet.
- */
-declare function serializeFrameTree(): SerializedFrameTree;
-/**
- * Install the Frame Visualizer Bridge.
- * Listens for postMessage events from the visualizer and responds
- * with serialized frame tree data.
- *
- * This should be called once during Framework.boot().
- */
-declare function installFrameVisualizerBridge(): void;
+declare function bindStore<T>(view: unknown, store: StoreApi<T>, selector?: (state: T) => Record<string, unknown>): () => void;
 
-export { type AnyFunc, CALL_BREAK_TIME, Cache, type CacheEntry, type CacheInterface, type CacheOptions, type ChangeEvent, type CompileOptions, CrossSite, type CrossSiteConfig, type DomElement, type DomOp, type DomRef, EVENT_METHOD_REGEXP, EventDelegator, EventEmitter, type EventEmitterInterface, type EventListenerEntry, Frame, type FrameBoundElement, type FrameInterface, type FrameInvokeEntry, type FrameStaticEvent, FrameVisualBridge, Framework, type FrameworkConfig, type FrameworkInterface, LARK_VIEW, type Location, type LocationDiff, type MixinEventHandler, type ParamDiff, type ParsedUri, Payload, type PayloadEntry, type PayloadInterface, type PendingCacheEntry, RouterEvents as ROUTER_EVENTS, type RouteChangeEvent, type RouteChangedEvent, type RouteViewConfig, Router, type RouterInterface, SPLITTER, type SerializedFrameNode, type SerializedFrameTree, type SerializedViewInfo, Service, type ServiceCacheInfo, type ServiceEntry, type ServiceEvent, type ServiceInterface, type ServiceMetaEntry, type ServiceOptions, State, type StateInterface, type StoreApi, TAG_NAME_REGEXP, Updater, type UpdaterInterface, VIEW_EVENT_METHOD_REGEXP, View, type ViewEvent, type ViewEventSelectorEntry, type ViewGlobalEventEntry, type ViewInterface, type ViewLocationObserved, type ViewObserveLocation, type ViewResourceEntry, type ViewTemplate, type VoidFunc, applyDomOps, applyIdUpdates, applyStyle, assign, bindStore, computed, create, createDomRef, defineStore, defineView, domGetCompareKey, domGetNode, domSetAttributes, domSetChildNodes, domSetNode, domSpecialDiff, domUnmountFrames, encodeHTML, encodeQ, encodeSafe, encodeURIExtra, ensureElementId, config as frameworkConfig, funcWithTry, generateId, getAttribute, getById, getRouteMode, hasOwnProperty, installFrameVisualizerBridge, invalidateViewClass, isPlainObject, isPrimitive, isPrimitiveOrFunc, keys, mark, markBooted, markRouterBooted, nextCounter, nodeInside, noop, now, parseUri, registerViewClass, resetProjectsMap, safeguard, serializeFrameTree, setData, syncCounter, toMap, toUri, translateData, unmark, use, useUrlState };
+export { type AnyFunc, CALL_BREAK_TIME, Cache, type CacheEntry, type CacheInterface, type CacheOptions, type ChangeEvent, type CompileOptions, CrossSite, type CrossSiteConfig, type DomElement, type DomOp, type DomRef, EVENT_METHOD_REGEXP, EventDelegator, EventEmitter, type EventEmitterInterface, type EventListenerEntry, Frame, type FrameBoundElement, type FrameInterface, type FrameInvokeEntry, type FrameStaticEvent, Framework, type FrameworkConfig, type FrameworkInterface, LARK_VIEW, type Location, type LocationDiff, type MixinEventHandler, type ParamDiff, type ParsedUri, Payload, type PayloadInterface, type PendingCacheEntry, RouterEvents as ROUTER_EVENTS, type RouteChangeEvent, type RouteChangedEvent, type RouteViewConfig, Router, type RouterInterface, SPLITTER, Service, type ServiceCacheInfo, type ServiceEvent, type ServiceMetaEntry, type ServiceOptions, State, type StateInterface, type StoreApi, TAG_NAME_REGEXP, Updater, type UpdaterInterface, type VDomCreateFn, type VDomNode, type VDomRef, type VDomTemplate, VIEW_EVENT_METHOD_REGEXP, View, type ViewEvent, type ViewEventSelectorEntry, type ViewGlobalEventEntry, type ViewInterface, type ViewLocationObserved, type ViewObserveLocation, type ViewResourceEntry, type ViewTemplate, type VoidFunc, applyStyle, bindStore, computed, create, createVDomRef, defineView, config as frameworkConfig, getRouteMode, invalidateViewClass, mark, markBooted, markRouterBooted, nextCounter, registerViewClass, resetProjectsMap, safeguard, unmark, use, useUrlState, vdomCreate };