@lark.js/mvc 0.0.2 → 0.0.4

package/dist/index.d.cts

@@ -1,14 +1,382 @@
+/**
+ * Base View class.
+ * Views are created via View.extend() and mounted by Frame.
+ */
+declare class View implements ViewInterface {
+    /** View ID (same as owner frame ID) */
+    id: string;
+    /** Owner frame */
+    owner: FrameInterface | number;
+    /** Updater instance */
+    updater: UpdaterInterface;
+    /** Signature: > 0 means active, incremented on render, 0 = destroyed */
+    signature: number;
+    /** Whether rendered at least once */
+    rendered?: boolean;
+    /** Whether view has template */
+    template?: (data: unknown, viewId: string, refData: unknown, ...rest: unknown[]) => string | string;
+    /** Location observation config */
+    locationObserved: ViewLocationObserved;
+    /** Observed state keys */
+    observedStateKeys?: string[];
+    /** Resource map */
+    resources: Record<string, ViewResourceEntry>;
+    /** Assign method reference */
+    assignMethod?: AnyFunc;
+    /** Whether endUpdate pending */
+    endUpdatePending?: number;
+    /** Internal event storage */
+    private _events;
+    /**
+     * Event bitmask map: eventType -> bitmask (1=root, 2=selector).
+     * Read from prototype ($evtObjMap) set by View.prepare.
+     * Using a getter avoids ES6 class field shadowing the prototype value.
+     */
+    get eventObjectMap(): Record<string, number>;
+    /**
+     * Selector event map: eventType -> selector list.
+     * Read from prototype ($selMap) set by View.prepare.
+     */
+    get eventSelectorMap(): Record<string, ViewEventSelectorEntry>;
+    /**
+     * Global event list: [{handler, element, eventName, modifiers}].
+     * Read from prototype ($globalEvtList) set by View.prepare.
+     */
+    get globalEventList(): ViewGlobalEventEntry[];
+    /**
+     * Initialize view (called by Frame when mounting).
+     */
+    init(): void;
+    /**
+     * Render view template (called by Frame after init).
+     * Wrapped by View.wrapMethod to manage signature + resources.
+     */
+    render(): void;
+    on(event: string, handler: AnyFunc): this;
+    off(event: string, handler?: AnyFunc): this;
+    fire(event: string, data?: Record<string, unknown>, remove?: boolean, lastToFirst?: boolean): this;
+    /**
+     * Notify view that HTML update is about to begin.
+     * Unmounts child frames in the update zone.
+     */
+    beginUpdate(id?: string): void;
+    /**
+     * Notify view that HTML update has ended.
+     * Mounts child frames in the update zone and runs deferred invokes.
+     */
+    endUpdate(id?: string, inner?: boolean): void;
+    /**
+     * Wrap an async callback to check view signature before executing.
+     * If the view has been re-rendered or destroyed, the callback is skipped.
+     */
+    wrapAsync<Fn extends AnyFunc>(fn: Fn, context?: unknown): (...args: Parameters<Fn>) => ReturnType<Fn> | undefined;
+    /**
+     * Observe location parameters or path changes.
+     * When observed keys change, render() is called automatically.
+     */
+    observeLocation(params: string | string[] | Record<string, unknown>, observePath?: boolean): void;
+    /**
+     * Observe State data keys for changes.
+     * When observed keys change via State.digest(), render() is called.
+     */
+    observeState(observedKeys: string | string[]): void;
+    /**
+     * Capture (register) a resource under a key.
+     * If a resource already exists at that key, it's destroyed first.
+     * When destroyOnRender=true, the resource is destroyed on next render call.
+     */
+    capture(key: string, resource?: unknown, destroyOnRender?: boolean): unknown;
+    /**
+     * Release a captured resource.
+     * If destroy=true, calls the resource's destroy() method.
+     */
+    release(key: string, destroy?: boolean): unknown;
+    /**
+     * Set up a leave confirmation for route changes and page unload.
+     */
+    leaveTip(message: string, condition: () => boolean): void;
+    /** Collected ctors from mixins */
+    static ctors?: AnyFunc[];
+    /**
+     * Prepare a View subclass by scanning its prototype for event method patterns.
+     * Pattern: `$?name<eventType1,eventType2>(&modifiers)`
+     *
+     * Only runs once per View subclass (guarded by ctors marker).
+     * Called from Frame.mountView before creating the view instance.
+     */
+    static prepare(oView: typeof View): AnyFunc[];
+    /**
+     * Bind or unbind event delegation for a view instance.
+     * Called from Frame during mount/unmount.
+     */
+    static delegateEvents(view: ViewInterface, destroy?: boolean): void;
+    /**
+     * Destroy all resources managed by a view.
+     * If lastly=true, destroy ALL resources; otherwise only destroyOnRender ones.
+     */
+    static destroyAllResources(view: ViewInterface, lastly: boolean): void;
+    /**
+     * Process deferred invoke calls on a frame.
+     */
+    static runInvokes(frame: FrameInterface): void;
+    /**
+     * Wrap a method on the prototype to add signature checking and resource cleanup.
+     */
+    private static wrapMethod;
+    /**
+     * When two mixins define the same event method, merge them into
+     * a single function that calls both in sequence.
+     */
+    private static processMixinsSameEvent;
+    /**
+     * Merge an array of mixin objects into the view prototype.
+     */
+    private static mergeMixins;
+    /**
+     * Destroy a single resource entry.
+     */
+    private static destroyResource;
+    /**
+     * Extend View to create a new View subclass.
+     *
+     * Supports:
+     * - props.make: constructor-like init (called with initParams + {node, deep})
+     * - props.mixins: array of mixin objects
+     * - Event method patterns: `'name<click>'` etc.
+     */
+    static extend(props?: ThisType<ViewInterface> & Record<string, unknown>, statics?: Record<string, unknown>): typeof View;
+    /**
+     * Merge mixins into View prototype.
+     */
+    static merge(this: typeof View, ...mixins: Record<string, unknown>[]): typeof View;
+}
+
+/**
+ * Multi-cast event emitter class.
+ *
+ * @example
+ * const emitter = new EventEmitter();
+ * emitter.on('change', (data) => console.log(data));
+ * emitter.fire('change', { key: 'value' });
+ */
+declare class EventEmitter<T = unknown> implements EventEmitterInterface<T> {
+    /** Event listeners: prefixed key -> listener array */
+    listeners: Map<string, EventListenerEntry[]>;
+    /**
+     * Bind event listener.
+     */
+    on(event: string, handler: (this: T, e: ChangeEvent) => void): this;
+    /**
+     * Unbind event listener.
+     * If handler is provided, removes only that handler.
+     * If no handler, removes all handlers for the event.
+     */
+    off(event: string, handler?: AnyFunc): this;
+    /**
+     * Fire event, execute all bound handlers.
+     * Supports executing state management: handlers removed during
+     * execution are safely handled.
+     *
+     * @param event - Event name
+     * @param data - Event data (type property added automatically)
+     * @param remove - Whether to remove all handlers after firing
+     * @param lastToFirst - Whether to execute handlers in reverse order
+     */
+    fire(event: string, data?: Record<string, unknown>, remove?: boolean, lastToFirst?: boolean): this;
+}
+
+/**
+ * Frame (View Frame) class for view lifecycle management.
+ * Each frame owns a view and manages child frames.
+ *
+ */
+declare class Frame extends EventEmitter implements FrameInterface {
+    /** Frame ID (same as owner DOM element ID) */
+    readonly id: string;
+    /** Parent Frame ID */
+    private _parentId;
+    get parentId(): string | undefined;
+    /** Children map: id -> id */
+    childrenMap: Record<string, string>;
+    /** Children count */
+    childrenCount: number;
+    /** Ready count (children that have fired 'created') */
+    readyCount: number;
+    /** Ready map: id -> 1 */
+    readyMap: Record<string, number>;
+    /** View instance */
+    viewInstance?: ViewInterface;
+    /** Get view instance (read-only) */
+    get view(): ViewInterface | undefined;
+    /** Invoke list for deferred method calls */
+    invokeList: FrameInvokeEntry[];
+    /** Signature for async operation tracking */
+    signature: number;
+    /** Whether view has altered */
+    hasAltered: number;
+    /** Whether view is destroyed */
+    destroyed: number;
+    /** View path (v-lark attribute value) */
+    viewPath?: string;
+    /** Original template before mount */
+    originalTemplate?: string;
+    /** Hold fire created flag */
+    holdFireCreated: number;
+    /** Children created flag */
+    childrenCreated: number;
+    /** Children alter flag */
+    childrenAlter: number;
+    constructor(id: string, parentId?: string);
+    /**
+     * Mount a view to this frame.
+     *
+     * Complete flow:
+     * 1. Parse viewPath, translate query params from parent
+     * 2. Unmount current view
+     * 3. Load View class (via require or provided ViewClass)
+     * 4. View_Prepare (scan event methods)
+     * 5. Create View instance
+     * 6. View_DelegateEvents (bind DOM events)
+     * 7. Call view.init()
+     * 8. If view has template, call render via Updater
+     * 9. If no template, call endUpdate directly
+     */
+    mountView(viewPath: string, viewInitParams?: Record<string, unknown>): void;
+    /**
+     * Internal: actually mount the view after class is loaded.
+     */
+    doMountView(ViewClass: typeof View, params: Record<string, string>, node: HTMLElement, sign: number): void;
+    /**
+     * Unmount current view.
+     */
+    unmountView(): void;
+    /**
+     * Mount a child frame.
+     */
+    mountFrame(frameId: string, viewPath: string, viewInitParams?: Record<string, unknown>): FrameInterface;
+    /**
+     * Unmount a child frame.
+     */
+    unmountFrame(id?: string, _inner?: boolean): void;
+    /**
+     * Mount all views in a zone.
+     */
+    mountZone(zoneId?: string, _inner?: boolean): void;
+    /**
+     * Unmount all views in a zone.
+     */
+    unmountZone(zoneId?: string, _inner?: boolean): void;
+    /**
+     * Get all child frame IDs.
+     */
+    children(): string[];
+    /**
+     * Get parent frame at given level.
+     * @param level - How many levels up (default 1)
+     */
+    parent(level?: number): Frame | undefined;
+    /**
+     * Invoke a method on the view.
+     */
+    invoke(name: string, args?: unknown[]): unknown;
+    /** Get frame by ID */
+    static get(id: string): Frame | undefined;
+    /** Get all frames */
+    static getAll(): Map<string, Frame>;
+    /** Get or create root frame */
+    static root(rootId?: string): Frame;
+    /** Bind event listener (static) */
+    static on(event: string, handler: AnyFunc): typeof Frame;
+    /** Unbind event listener (static) */
+    static off(event: string, handler?: AnyFunc): typeof Frame;
+    /** Fire event (static) */
+    static fire(event: string, data?: Record<string, unknown>): void;
+}
+/**
+ * Register a View class for a given view path.
+ * Called after module loading completes.
+ */
+declare function registerViewClass(viewPath: string, ViewClass: typeof View): 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.
+     */
+    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 least-used entries from cache */
+    private evictEntries;
+}
+
 /**
  * Lark framework type definitions.
  * All shared types are defined here to eliminate type cheats across modules.
+ *
+ * Lark is a lightweight MVC frontend framework that provides:
+ * - View: base view class with extend/merge inheritance and mixin support
+ * - Router: hash-based two-phase route confirmation
+ * - State: cross-view observable global state management
+ * - Service: API request management with caching, queuing, and deduplication
+ * - Frame: view frame managing view mount/unmount lifecycle
+ * - Updater: view data binding and VDOM diff (in-memory real DOM diff) renderer
+ *
+ * Designed for single-page application (SPA) development.
  */
 /** Generic function type for event handlers and callbacks.
  *  Uses any[] to accept callbacks with specific parameter types
  *  (TypeScript function parameters are contravariant).
  */
 type AnyFunc = (...args: any[]) => unknown;
-/** A function that returns void. */
-type VoidFunc = (...args: any[]) => void;
 interface CacheEntry<T> {
     /** Original key without prefix */
     originalKey: string;
@@ -29,81 +397,184 @@ interface CacheOptions<T> {
     /** Comparator for sorting entries */
     sortComparator?: (a: CacheEntry<T>, b: CacheEntry<T>) => number;
 }
+/**
+ * Cache interface providing LFU (Least Frequently Used) cache management.
+ * Cache keys use a special prefix internally for namespace isolation.
+ */
+interface CacheInterface<T = unknown> {
+    /**
+     * Set a cache resource. If the key exists, updates the value and increments frequency.
+     * Triggers LFU eviction when cache entries exceed capacity (maxSize + bufferSize).
+     * @param key Unique identifier for the cached resource
+     * @param resource The resource to cache
+     */
+    set(key: string, resource: T): void;
+    /**
+     * Get a cached resource. Access increments frequency count and timestamp for LFU ranking.
+     * Returns undefined if the key does not exist.
+     * @param key Cache resource key
+     */
+    get(key: string): T | undefined;
+    /**
+     * Remove a resource from cache by key. Triggers onRemove callback on deletion.
+     * @param key Cache resource key to remove
+     */
+    del(key: string): void;
+    /**
+     * Check if cache contains a resource for the given key.
+     * @param key Cache resource key
+     */
+    has(key: string): boolean;
+    /**
+     * Iterate over all cached resource values.
+     * @param callback Iteration callback receiving the cached value (may be undefined)
+     */
+    forEach(callback: (value: T | undefined) => void): void;
+    /**
+     * Number of cache entries.
+     */
+    readonly size: number;
+    /**
+     * Clear all cache entries. Triggers onRemove callback for each deleted entry.
+     */
+    clear(): void;
+}
 interface EventListenerEntry {
     /** Handler function */
     handler: AnyFunc;
     /** Whether currently executing (1 = executing, '' = done) */
     executing: number | string;
 }
+/**
+ * Parsed URL result containing path and parameters.
+ * Returned by `Router.parse()`, includes the path string and parsed key-value parameter pairs.
+ */
 interface ParsedUri {
-    /** Path portion (before ? or #) */
+    /** Path portion (before ? or #), excluding query parameters */
     path: string;
-    /** Key-value params */
+    /** Key-value params parsed from the URL */
     params: Record<string, string>;
 }
+/**
+ * Current URL parsing result interface.
+ * Returned by `Router.parse()`, includes both query (after ?) and hash (after #) sections.
+ */
 interface Location {
-    /** Full href */
+    /** Full href, original href string */
     href: string;
-    /** Query string (before #) */
+    /** Query string (before #), raw query string (after ?, before #) */
     srcQuery: string;
-    /** Hash string (after #) */
+    /** Hash string (after #), raw hash string (after #) */
     srcHash: string;
-    /** Parsed query object */
+    /** Parsed query object, path and params parsed from srcQuery */
     query: ParsedUri;
-    /** Parsed hash object */
+    /** Parsed hash object, path and params parsed from srcHash */
     hash: ParsedUri;
-    /** Merged params from query and hash */
+    /**
+     * Merged params from query and hash,
+     * hash values take precedence when keys conflict.
+     */
     params: Record<string, string>;
-    /** Resolved view path */
+    /**
+     * Resolved view path for the current URL.
+     * May be undefined before framework boot.
+     */
     view?: string;
-    /** Resolved path */
+    /**
+     * Resolved path computed from hash path and query path based on routing rules.
+     * May be undefined before framework boot.
+     */
     path?: string;
-    /** Get param by key with optional default */
+    /**
+     * Get param by key with optional default value.
+     * Returns default value or empty string if key does not exist.
+     * @param key Parameter key name
+     * @param defaultValue Default value when key is missing, defaults to empty string
+     */
     get: (key: string, defaultValue?: string) => string;
 }
+/**
+ * URL parameter change representing a parameter value transition from old to new.
+ * Used in `Router.diff()` return value to describe parameter changes.
+ */
 interface ParamDiff {
+    /** Value before the change */
     from: string;
+    /** Value after the change */
     to: string;
 }
+/**
+ * URL route change object interface describing changes between two routing states.
+ * Returned by `Router.diff()`, includes changes in path, view, and other parameters.
+ */
 interface LocationDiff {
-    /** Changed params (key -> {from, to}) */
+    /**
+     * Changed params (key -> {from, to}),
+     * diff for all changed parameters
+     */
     params: Record<string, ParamDiff>;
-    /** Whether path changed */
+    /** Path diff when path has changed */
     path?: ParamDiff;
-    /** Whether view changed */
+    /** View diff when rendered view has changed */
     view?: ParamDiff;
-    /** Whether this is a first forced change */
+    /**
+     * Whether this is a first forced change during app initialization.
+     */
     force: boolean;
-    /** Whether anything changed */
+    /** Whether any content has changed */
     changed: boolean;
 }
+/**
+ * Route pre-change event interface (change phase).
+ * Provides two-phase confirmation: triggers change (can be rejected), then changed.
+ * Can prevent, reject, or accept route changes through this event object.
+ */
+interface RouteChangeEvent extends ChangeEvent {
+    /**
+     * Reject the URL change, revert to previous URL.
+     */
+    reject: () => void;
+    /**
+     * Accept the URL change, continue navigation.
+     */
+    resolve: () => void;
+    /**
+     * Prevent the URL change, pause subsequent route processing.
+     */
+    prevent: () => void;
+}
+/**
+ * Route post-change event interface (changed phase).
+ * Carries route diff information. Triggered after route change is confirmed and URL is updated.
+ */
+type RouteChangedEvent = LocationDiff & ChangeEvent;
 interface VDomRef {
     /** ID update list: [element, newId][] */
     idUpdates: [Element, string][];
     /** Views that need post-processing */
-    views: ViewInstance[];
+    views: ViewInterface[];
     /** DOM operation list: [opCode, parent, newChild?, oldChild?][] */
     domOps: VDomOp[];
     /** Whether anything changed */
     hasChanged: number;
 }
 type VDomOp = [1, Element, Element] | [2, Element, Element] | [4, Element, Element, Element] | [8, Element, Element, Element];
-type FrameChildrenMap = Record<string, string>;
-type FrameReadyMap = Record<string, number>;
 interface FrameInvokeEntry {
     /** Method name */
     name: string;
     /** Method arguments */
     args: unknown[];
-    /** Internal key for dedup */
+    /** Internal key */
     key: string;
     /** Whether removed (args match) */
     removed?: boolean;
 }
 /** Mixin event handler with internal merge marker and handler list */
 interface MixinEventHandler extends AnyFunc {
-    /** Merged handler list */ a?: AnyFunc[];
-    /** Mixin marker: 1 = this is a mixin function */ b?: number;
+    /** Merged handler list */
+    handlerList?: AnyFunc[];
+    /** Mixin marker: 1 = this is a mixin function */
+    marker?: number;
 }
 /** View event selector map entry: handler name list with selector presence tracking */
 interface ViewEventSelectorEntry {
@@ -112,8 +583,6 @@ interface ViewEventSelectorEntry {
     /** Index signature for checking if selector is already registered */
     [selector: string]: unknown;
 }
-/** View class internal markers (SPLITTER key) */
-type ViewClassInternal = Record<string, AnyFunc[]>;
 interface ViewLocationObserved {
     /** Whether observing location */
     flag: number;
@@ -128,8 +597,6 @@ interface ViewResourceEntry {
     /** Whether to destroy when render() is called */
     destroyOnRender: boolean;
 }
-type ViewResourceMap = Record<string, ViewResourceEntry>;
-type ViewEventSelectorMap = Record<string, ViewEventSelectorEntry>;
 interface ViewGlobalEventEntry {
     /** Handler function */
     handler: AnyFunc;
@@ -142,30 +609,105 @@ interface ViewGlobalEventEntry {
     /** Modifiers */
     modifiers: Record<string, boolean>;
 }
-type ViewEventObjectMap = Record<string, number>;
-interface ViewInstance {
-    /** View ID (same as owner frame ID) */
+/**
+ * Router interface providing URL parsing, navigation, diff, and event listening capabilities.
+ * Supports two-phase route confirmation mechanism: change (can reject) → changed.
+ * Hash-based implementation using #! as default hash prefix.
+ */
+interface RouterInterface extends EventEmitterInterface<RouterInterface> {
+    /**
+     * Parse href into Location object.
+     * Parses query and hash sections of href, returns structured routing information.
+     * Defaults to parsing current page `location.href`.
+     * @param href URL to parse, uses `location.href` if not specified
+     */
+    parse(href?: string): Location;
+    /**
+     * Compute diff between current and previous location.
+     * Returns undefined if no routing changes have occurred yet.
+     */
+    diff(): LocationDiff | undefined;
+    /**
+     * Navigate to new URL.
+     * Supports two calling modes:
+     * - `Router.to("/list", { page: 2 })` specify path and params
+     * - `Router.to({ page: 2 })` update params only, keep current path
+     * @param pathOrParams Path string or params object
+     * @param params Query params object (only used when first arg is path string)
+     * @param replace Whether to replace current history entry instead of adding new one
+     * @param silent Whether to silently update without triggering change event
+     */
+    to(pathOrParams: string | Record<string, unknown>, params?: Record<string, unknown>, replace?: boolean, silent?: boolean): void;
+    /** Join path segments */
+    join(...paths: string[]): string;
+    /** Internal: bind hashchange (called by Framework.boot) */
+    _bind(): void;
+    /** Internal: set framework config */
+    _setConfig(cfg: FrameworkConfig): void;
+    /** Internal: notify hash change (for programmatic trigger) */
+    notify?(e?: Event): void;
+    /**
+     * Triggered when URL is about to change (change phase), can reject or prevent navigation via event object.
+     */
+    onChange?: (e?: RouteChangeEvent) => void;
+    /**
+     * Triggered after URL has changed (changed phase), carries route diff information.
+     */
+    onChanged?: (e?: RouteChangedEvent) => void;
+}
+/**
+ * Frame static event interface carrying associated Frame instance.
+ * Carried in Frame's add/remove static events.
+ */
+interface FrameStaticEvent extends ChangeEvent {
+    /**
+     * Associated Frame instance object.
+     */
+    readonly frame: FrameInterface;
+}
+interface ViewInterface extends EventEmitterInterface<ViewInterface> {
+    /**
+     * View ID (same as owner frame ID),
+     * DOM node ID where current view resides.
+     */
     id: string;
-    /** Owner frame */
-    owner: FrameLike | number;
-    /** Updater instance */
-    updater: UpdaterLike;
-    /** Signature: > 0 means active, incremented on render, 0 = destroyed */
+    /**
+     * Owner frame,
+     * Frame instance holding current view.
+     * May be numeric placeholder 0 before view initialization completes.
+     * TODO: Migrate numeric placeholder 0 to undefined or null
+     */
+    owner: FrameInterface | number;
+    /**
+     * Updater instance managing view data binding and VDOM rendering.
+     */
+    updater: UpdaterInterface;
+    /**
+     * Signature: > 0 means active, incremented on render, 0 = destroyed */
     signature: number;
     /** Whether rendered at least once */
     rendered?: boolean;
-    /** Whether view has template */
-    template?: AnyFunc | string;
+    /**
+     * View template supporting function or string template.
+     * Function template signature: `(data: unknown, viewId: string, refData: unknown, ...rest: unknown[]) => string`
+     */
+    template?: (data: unknown, viewId: string, refData: unknown, ...rest: unknown[]) => string | string;
+    /**
+     * Mixin object array for extending view functionality.
+     * Framework merges properties and methods from mixins into view prototype.
+     * Event method conflicts are automatically merged into sequential calls.
+     */
+    mixins?: Record<string, unknown>[];
     /** Location observation config */
     locationObserved: ViewLocationObserved;
     /** Observed state keys */
     observedStateKeys?: string[];
     /** Resource map */
-    resources: ViewResourceMap;
+    resources: Record<string, ViewResourceEntry>;
     /** Selector event map: eventType -> selector list */
-    eventSelectorMap: ViewEventSelectorMap;
+    eventSelectorMap: Record<string, ViewEventSelectorEntry>;
     /** Event object map: eventType -> bitmask */
-    eventObjectMap: ViewEventObjectMap;
+    eventObjectMap: Record<string, number>;
     /** Global event list */
     globalEventList: ViewGlobalEventEntry[];
     /** Assign method reference */
@@ -173,53 +715,366 @@ interface ViewInstance {
     /** Whether endUpdate has been called (1 = pending) */
     endUpdatePending?: number;
     /** Render method (wrapped) */
-    render: AnyFunc;
-    /** init method */
-    init: AnyFunc;
+    render(): void;
+    /**
+     * Init method called after view is mounted.
+     * Used for initialization logic.
+     * Framework passes two arguments during actual invocation:
+     * - initParams: initialization parameter object
+     * - options: contains `node: Element` and `deep: boolean`
+     */
+    init(): void;
     /** Wrapped render method */
-    $b?: AnyFunc;
+    renderMethod?: AnyFunc;
     /** endUpdate pending flag */
-    $e?: number;
-    on: (event: string, handler: AnyFunc) => ViewInstance;
-    off: (event: string, handler?: AnyFunc) => ViewInstance;
-    fire: (event: string, data?: Record<string, unknown>, remove?: boolean, lastToFirst?: boolean) => ViewInstance;
+    endUpdatePendingFlag?: number;
+    /**
+     * Notify view that HTML update is about to begin for a specific region.
+     * Framework unmounts child Frames in that region to prevent VDOM diff from operating on unmounted nodes.
+     * @param id Region node ID to update, defaults to current view
+     */
     beginUpdate: (id?: string) => void;
+    /**
+     * Notify view that HTML update has completed for a specific region.
+     * Framework mounts child Frames in that region and executes deferred invoke queue.
+     * @param id Region node ID that finished updating, defaults to current view
+     * @param inner Whether this is an internal framework call
+     */
     endUpdate: (id?: string, inner?: boolean) => void;
+    /**
+     * Wrap async callback to ensure it only executes if view is not destroyed.
+     * In SPAs, async callbacks (e.g., setTimeout, AJAX) may execute after view is destroyed,
+     * causing errors when manipulating DOM.
+     * After wrapping with `wrapAsync`, framework automatically checks view state and only executes callback if view is alive.
+     * @param fn Callback function to wrap
+     * @param context `this` binding for callback execution, defaults to view itself
+     */
     wrapAsync: <Fn extends AnyFunc>(fn: Fn, context?: unknown) => (...args: Parameters<Fn>) => ReturnType<Fn> | undefined;
+    /**
+     * Listen for URL bar changes, supports two calling modes:
+     * - `observeLocation("page,size", true)` pass parameter keys (comma-separated) and whether to observe path
+     * - `observeLocation({ params: ["page", "size"], path: true })` pass config object
+     * View automatically re-renders when observed parameters or path change.
+     * @param params Parameter keys to observe, supports comma-separated string, string array, or config object
+     * @param observePath Whether to observe path changes
+     */
     observeLocation: (params: string | string[] | Record<string, unknown>, observePath?: boolean) => void;
+    /**
+     * Observe data changes for specified keys in State.
+     * View automatically re-renders when observed keys are updated via `State.digest()`.
+     * @param keys Comma-separated key string or string array
+     */
     observeState: (keys: string | string[]) => void;
+    /**
+     * Hand over resource to current view for lifecycle management.
+     * Framework automatically calls resource's destroy method at appropriate time when view unmounts or re-renders.
+     * @param key Unique key for managed resource; if key already manages different resource, old resource is auto-destroyed
+     * @param resource Resource object to manage
+     * @param destroyOnRender Whether to auto-destroy resource when render method is called; Service instances typically need auto-destroy on render
+     */
     capture: (key: string, resource?: unknown, destroyOnRender?: boolean) => unknown;
+    /**
+     * Release managed resource, returns the resource object regardless of destruction state.
+     * @param key Managed resource key
+     * @param destroy Whether to destroy resource (call its destroy method), defaults to true
+     */
     release: (key: string, destroy?: boolean) => unknown;
+    /**
+     * Set leave prompt, e.g., when form has unsaved changes.
+     * Can prompt user to choose between leaving directly or saving before leaving.
+     * Framework calls condition function during route changes (change phase) and page unloads (beforeunload).
+     * Navigation is prevented if condition returns true.
+     * @param message Leave prompt message
+     * @param condition Function to determine whether to show leave prompt; returns true to prevent navigation
+     */
     leaveTip: (message: string, condition: () => boolean) => void;
-    assign: (options?: unknown) => boolean | undefined;
+    /**
+     * Assign method for incremental DOM updates.
+     * Framework uses VDOM diff (in-memory real DOM diff) to update only changed portions,
+     * automatically handling child view mounting and unmounting.
+     * Returns true if DOM changed, undefined if no change.
+     * @param options Incremental update config, used internally by framework
+     */
+    assign?: (options?: unknown) => boolean | undefined;
+    /**
+     * Triggered when view is destroyed.
+     */
+    onDestroy?: (e?: ChangeEvent) => void;
+    /**
+     * Triggered when render method is called.
+     */
+    onRender?: (e?: ChangeEvent) => void;
+    /**
+     * Inherit View to create new view subclass.
+     * Supports props.make constructor, props.mixins, and event methods (e.g., `'name<click>'`).
+     * @param props Prototype object containing init, render, and other methods
+     * @param statics Object of static methods or properties
+     */
+    extend?<TProps = object, TStatics = object>(props?: ExtendThisType<TProps & ViewInterface>, statics?: TStatics): ViewInterface & TStatics;
+    /**
+     * Merge multiple mixin objects into View prototype.
+     * Existing properties are not overwritten; event method conflicts are automatically merged into sequential calls.
+     * @param args Mixin object list
+     */
+    merge?(...args: ExtendThisType<ViewInterface>[]): ViewInterface;
 }
-/** Minimal Frame interface needed by View */
-interface FrameLike {
+type ExtendThisType<T> = Record<string, unknown> & ThisType<T>;
+/**
+ * Minimal Frame interface needed by View.
+ * Frame (View Frame) is a view container managing view mount, unmount, and parent-child hierarchy.
+ * Each Frame corresponds to one DOM node, associated with view via v-lark attribute.
+ */
+interface FrameInterface extends EventEmitterInterface<FrameInterface> {
+    /**
+     * DOM node ID where Frame resides.
+     */
     id: string;
-    parentId: string | undefined;
-    unmountZone: (zoneId?: string, inner?: boolean) => void;
-    mountZone: (zoneId?: string, inner?: boolean) => void;
-    mountFrame: (frameId: string, viewPath: string, viewInitParams?: Record<string, unknown>) => FrameLike;
+    /**
+     * View module path currently rendered by this Frame, e.g., "app/views/default".
+     */
+    readonly viewPath?: string;
+    /**
+     * Parent Frame ID, undefined if this is a top-level Frame.
+     */
+    readonly parentId: string | undefined;
+    /**
+     * Mount view to current Frame.
+     * Framework loads view class, creates instance, and renders view.
+     * @param viewPath View module path, e.g., "app/views/default"
+     * @param viewInitParams Parameters passed during view initialization, accessible in view's init method
+     */
+    mountView(viewPath: string, viewInitParams?: Record<string, unknown>): void;
+    /**
+     * Unmount view from current Frame, triggers view's destroy event and cleans up resources.
+     */
+    unmountView(): void;
+    /**
+     * Mount child Frame on specified DOM node and render view.
+     * @param frameId DOM node ID for rendering
+     * @param viewPath View path
+     * @param viewInitParams Parameters passed during view initialization
+     */
+    mountFrame: (frameId: string, viewPath: string, viewInitParams?: Record<string, unknown>) => 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;
-    view: ViewInstance | undefined;
-    children: () => string[];
+    /**
+     * 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;
+    /**
+     * Unmount all child views under specified node.
+     * @param zoneId DOM node ID, defaults to current Frame
+     */
+    unmountZone: (zoneId?: string, inner?: boolean) => void;
+    /**
+     * Get ancestor Frame, defaults to parent Frame (level=1).
+     * @param level Levels to traverse upward, defaults to 1
+     */
+    parent(level?: number): FrameInterface | undefined;
+    /**
+     * Invoke specified method on view in current Frame.
+     * If view is not rendered yet, invocation is deferred until render completes.
+     * @param name Method name
+     * @param args Arguments array passed to method
+     */
     invoke: (name: string, args?: unknown[]) => unknown;
+    /**
+     * Triggered when all descendant views have been created.
+     */
+    onCreated?: (e?: ChangeEvent) => void;
+    /**
+     * Triggered when descendant views change.
+     */
+    onAlter?: (e?: ChangeEvent) => void;
+    /**
+     * Get Frame instance by ID, returns undefined if not exists.
+     * @param id Frame's DOM node ID
+     */
+    get?(id: string): FrameInterface | undefined;
+    /**
+     * Get all Frame instances map for current page.
+     */
+    getAll?(): Map<string, FrameInterface>;
+    /**
+     * Triggered when Frame is created and registered.
+     */
+    onAdd?: (e?: FrameStaticEvent) => void;
+    /**
+     * Triggered when Frame is destroyed and unregistered.
+     */
+    onRemove?: (e?: FrameStaticEvent) => void;
+    view: ViewInterface | undefined;
+    /**
+     * Get ID array of all child Frames for current Frame.
+     * Note: ID positions in array are not fixed.
+     */
+    children: () => string[];
     invokeList: FrameInvokeEntry[];
-    on: (event: string, handler: AnyFunc) => FrameLike;
-    off: (event: string, handler?: AnyFunc) => FrameLike;
-    fire: (event: string, data?: Record<string, unknown>) => FrameLike;
 }
-/** Minimal Updater interface needed by View */
-interface UpdaterLike {
+/**
+ * Minimal Updater interface needed by View.
+ * View updater responsible for view data binding and data/page updates.
+ * Each View instance has an Updater, triggering data/page updates via set/digest.
+ * Internally executes complete pipeline: template rendering → VDOM diff (in-memory real DOM diff) → DOM operations.
+ */
+interface UpdaterInterface {
+    /**
+     * Get data that has been set.
+     * Returns complete data object if key is omitted, otherwise returns value for specified key.
+     * @param key Data key name, omitted returns complete data object
+     */
     get: <T = unknown>(key?: string) => T;
-    set: (data: Record<string, unknown>, excludes?: Set<string>) => UpdaterLike;
-    digest: (data?: Record<string, unknown>, excludes?: Set<string>) => void;
-    /** Save a snapshot of current data for altered() detection */
-    snapshot: () => this;
-    /** Check if data has changed since last snapshot */
+    /**
+     * Set data and track changed keys.
+     * After set, must explicitly call `digest()` to commit changes to page.
+     * Returns this for chaining.
+     * @param data Data object, e.g., `{ a: 1, b: 2 }`
+     * @param excludes Set of keys to exclude from change tracking
+     */
+    set: (data: Record<string, unknown>, excludes?: Set<string>) => UpdaterInterface;
+    /**
+     * Trigger page re-render.
+     * After set, must explicitly call `digest()` to commit changes to page.
+     * Internally executes complete pipeline: template rendering → VDOM diff (in-memory real DOM diff) → DOM operations.
+     * @param data Optional data object, if provided calls `set()` first to set data
+     * @param excludes Set of keys to exclude from change tracking
+     * @param callback Callback executed after render completes
+     */
+    digest: (data?: Record<string, unknown>, excludes?: Set<string>, callback?: () => void) => void;
+    /**
+     * Save a snapshot of current data for altered() detection.
+     * Works with `altered()` method to detect whether data has changed.
+     */
+    snapshot: () => UpdaterInterface;
+    /**
+     * Check if data has changed since last snapshot.
+     * Returns undefined if `snapshot()` has not been called.
+     */
     altered: () => boolean | undefined;
     /** Ref data for template rendering */
     refData: Record<string, unknown>;
+    /**
+     * Translate raw reference data starting with @ symbol in template.
+     * Replaces `{{@refData}}` with actual value from refData.
+     * @param data Reference data to translate
+     */
+    translate(data: unknown): unknown;
+    /**
+     * Parse expression string.
+     * @param expr Expression string to parse
+     */
+    parse(expr: string): unknown;
+}
+/**
+ * Data payload interface wrapping API request response data, providing read/write methods.
+ * Payload instances are created internally by Service, developers access via all/one/save callbacks.
+ */
+interface PayloadInterface {
+    /**
+     * Get data from Payload by key.
+     * @param key Data key name
+     */
+    get<T = unknown>(key: string): T;
+    /**
+     * Set data to Payload, supports three calling modes:
+     * - Key-value pair: `payload.set("name", "value")`
+     * - Data object: `payload.set({ name: "value" })`
+     * - Endpoint metadata object (for internal framework use)
+     * Returns this for chaining.
+     * @param keyOrData Key/value string, data object, or endpoint metadata object
+     * @param value Value when first parameter is a key
+     */
+    set(keyOrData: string | Record<string, unknown> | ServiceMetaEntry, value?: unknown): PayloadInterface;
+    data: Record<string, unknown>;
+    cacheInfo?: ServiceCacheInfo;
+}
+/**
+ * Change event object.
+ */
+interface ChangeEvent {
+    /**
+     * Event type.
+     */
+    readonly type: string;
+    /**
+     * Set object of changed data keys, value 1 indicates key has changed.
+     * TODO: Optimize to Set data structure.
+     */
+    readonly keys?: Readonly<Record<string, 1>>;
+}
+/**
+ * Event emitter interface providing on/off/fire methods for publish-subscribe pattern.
+ */
+interface EventEmitterInterface<T = unknown> {
+    /**
+     * Bind event listener, calls handler when event is triggered.
+     * @param name Event name
+     * @param fn Event handler function
+     */
+    on(name: string, fn: (this: T, e?: ChangeEvent) => void): EventEmitterInterface<T>;
+    /**
+     * Unbind event listener, removes all handlers for event if no handler function is provided.
+     * @param name Event name
+     * @param fn Optional event handler function, if omitted removes all handlers
+     */
+    off(name: string, fn?: AnyFunc): EventEmitterInterface<T>;
+    /**
+     * Fire event, executes all bound handlers, automatically adds type property to event data.
+     * Supports removing all handlers after firing.
+     * Supports executing handler list in reverse order.
+     * @param name Event name
+     * @param data Event data object
+     * @param remove Whether to remove all handlers after firing
+     * @param lastToFirst Whether to execute handler list in reverse order
+     */
+    fire(name: string, data?: Record<string, unknown>, remove?: boolean, lastToFirst?: boolean): EventEmitterInterface<T>;
+}
+/**
+ * Global state interface providing cross-view data sharing and data change notification capabilities.
+ * State is a singleton object managing app-level state data via get/set/digest.
+ * Supports `clean()` method to create a mixin for automatic cleanup on view destruction.
+ */
+interface StateInterface extends EventEmitterInterface<StateInterface> {
+    /**
+     * Get data from global state, returns complete state object if key is omitted.
+     * @param key Data key name, omitted returns complete state object
+     */
+    get<T = unknown>(key?: string): T;
+    /**
+     * Set global state data.
+     * After set, must explicitly call `digest()` to dispatch changed event and notify views to update.
+     * @param data Data object, e.g., `{ a: 1, b: 2 }`
+     * @param excludes Set of keys to exclude from change tracking
+     */
+    set(data: Record<string, unknown>, excludes?: Set<string>): this;
+    /**
+     * Clean data for specified keys in State, can only be used in view's mixins.
+     * For example `mixins: [State.clean("a,b")]`.
+     * Keys registered via this method are automatically cleaned when view is destroyed,
+     * and corresponding key reference counts are decremented; data is auto-deleted when count reaches zero.
+     * @param keys Comma-separated key string
+     * @returns Object with make method, called by mixins mechanism
+     */
+    clean(keys: string): {
+        make: AnyFunc;
+    };
+    /**
+     * Detect data changes and dispatch changed event.
+     * After set, must explicitly call `digest()` to dispatch changed event and notify views to update.
+     * @param data Optional data object, if provided calls `set()` first to set data
+     * @param excludes Set of keys to exclude from change tracking
+     */
+    digest(data?: Record<string, unknown>, excludes?: Set<string>): void;
+    /**
+     * Triggered when state data changes.
+     */
+    diff: () => Readonly<Record<string, number>>;
+    onChanged?: (e?: ChangeEvent) => void;
 }
 interface ServiceOptions {
     /** Request URL */
@@ -227,14 +1082,14 @@ interface ServiceOptions {
     /** Request params */
     params?: Record<string, unknown>;
     /** HTTP method */
-    method?: "GET" | "POST" | "PUT" | "DELETE";
+    method?: "GET" | "POST" | "PUT" | "DELETE" | string;
     /** Cache: true for default, number for TTL */
     cache?: boolean | number;
     /** POST data */
     data?: unknown;
 }
-interface BagEntry {
-    /** Bag data */
+interface PayloadEntry {
+    /** Payload data */
     data: Record<string, unknown>;
 }
 interface ServiceEntry {
@@ -244,8 +1099,8 @@ interface ServiceEntry {
     url: string;
     /** Cache time in ms, 0 = no cache */
     cacheTime: number;
-    /** Bag instance */
-    bag?: BagEntry;
+    /** Payload instance */
+    payload?: PayloadEntry;
     /** Whether loading */
     loading?: boolean;
     /** Error info */
@@ -253,26 +1108,54 @@ interface ServiceEntry {
 }
 /** Pending cache entry for deduplication (internal to Service) */
 interface PendingCacheEntry extends Array<unknown> {
-    /** Reference to the pending Bag entity */
-    e?: unknown;
+    /** Reference to the pending Payload entity */
+    entity?: unknown;
 }
+/**
+ * Endpoint metadata configuration for registering an API endpoint with Service.
+ * Each meta describes endpoint's URL, cache strategy, before/after interceptors, etc.
+ */
 interface ServiceMetaEntry {
-    /** Endpoint name */
+    /**
+     * Endpoint name,
+     * Unique name for endpoint metadata, must be unique within same Service.
+     */
     name: string;
-    /** URL */
+    /** Request URL, required. */
     url: string;
-    /** Cache TTL in ms, 0 = no cache */
+    /**
+     * Cache TTL in ms, 0 = no cache.
+     * Cache validity time in milliseconds.
+     * 0 means no caching.
+     * Greater than 0 means cache TTL, reuse cached data within this time range.
+     */
     cache?: number;
-    /** Before-fetch hook */
-    before?: AnyFunc;
-    /** After-fetch hook */
-    after?: AnyFunc;
-    /** Clean keys on destroy */
-    cleans?: string;
+    /**
+     * Before-fetch hook,
+     * Hook function called before request is sent, can process request data.
+     * `this` points to current Payload instance.
+     * @param payload Data carrier for current request
+     */
+    before?: (this: PayloadInterface, payload: PayloadInterface) => void;
+    /**
+     * After-fetch hook.
+     * Hook function called after request succeeds, before data is passed to view.
+     * Can process response data in this method.
+     * `this` points to current Payload instance.
+     * @param payload Data carrier for current request
+     */
+    after?: (this: PayloadInterface, payload: PayloadInterface) => void;
+    /** Clean keys on destroy,
+     * Comma-separated endpoint name string for clearing other endpoints' cache.
+     * For example, if an endpoint creates new data,
+     * after successful call, should clear all data-fetching endpoints' cache,
+     * otherwise new data cannot be retrieved.
+     */
+    cleanKeys?: string;
     /** Additional properties */
     [key: string]: unknown;
 }
-/** Cache info attached to Bag entity */
+/** Cache info attached to Payload entity */
 interface ServiceCacheInfo {
     /** Endpoint name */
     name: string;
@@ -285,34 +1168,252 @@ interface ServiceCacheInfo {
     /** Timestamp when cached */
     time: number;
 }
+interface FrameworkInterface {
+    /**
+     * Get or update configuration.
+     * - When passing config object: merges config and returns merged config
+     * - When passing key name: returns config value for that key
+     * - When no arguments: returns complete config object
+     * @param cfg Config object or key name
+     */
+    config<T extends object = Partial<FrameworkConfig>>(cfg?: Partial<FrameworkConfig> & T): FrameworkConfig & T;
+    config(key: string): unknown;
+    /**
+     * App initialization entry point, starts framework and renders root view.
+     * After invocation: merge config → bind route events → create root Frame → mount default view.
+     * @param cfg Config object
+     */
+    boot(cfg: FrameworkConfig): void;
+    /**
+     * Convert array to hash map object.
+     * - Simple array: `Framework.toMap([1,2,3])` => `{1:1, 2:1, 3:1}`
+     * - Object array: `Framework.toMap([{id:20},{id:30}], 'id')` => `{20:{id:20}, 30:{id:30}}`
+     * @param list Source array
+     * @param key Use object's key value from array as map key
+     */
+    toMap<T>(list: T[] | null | undefined, key?: keyof T): Record<string, T | number>;
+    /**
+     * Execute methods in try-catch manner, catches exceptions.
+     * Returns return value of last successfully executed method.
+     * @param fns Function or function array
+     * @param args Arguments array passed to functions
+     * @param context `this` binding during function execution
+     */
+    toTry(fns: AnyFunc | AnyFunc[], args?: unknown[], context?: unknown): unknown;
+    /**
+     * Convert path and params to URL string.
+     * Example: `Framework.toUrl('/xxx/', {a:'b',c:'d'})` => `/xxx/?a=b&c=d`
+     * @param path Path string
+     * @param params Params object
+     * @param keepEmpty Set of keys to keep empty values
+     */
+    toUrl(path: string, params?: Record<string, unknown>, keepEmpty?: Record<string, number>): string;
+    /**
+     * Parse URL string to path and params object.
+     * Example: `Framework.parseUrl('/xxx/?a=b&c=d')` => `{path:'/xxx/', params:{a:'b',c:'d'}}`
+     * @param url URL string
+     */
+    parseUrl(url: string): ParsedUri;
+    /**
+     * Merge source object properties into target object.
+     * @param target Target object
+     * @param sources One or more source objects
+     */
+    mix<T extends object>(target: T, ...sources: Partial<T>[]): T;
+    /**
+     * Check if object has specified own property (safe hasOwnProperty).
+     * @param owner Object to check, supports undefined/null
+     * @param prop Property key name
+     */
+    has<T extends object>(owner: T | undefined | null, prop: PropertyKey): boolean;
+    /**
+     * Get enumerable property keys of object as array.
+     * @param src Source object
+     */
+    keys<T extends object>(src: T): string[];
+    /**
+     * Check if one DOM node is contained within another.
+     * Returns true if both nodes are the same.
+     * @param node Node or node ID
+     * @param container Container node or node ID
+     */
+    inside(node: HTMLElement | string, container: HTMLElement | string): boolean;
+    /**
+     * Shorthand for document.getElementById.
+     * Returns directly if Element is passed.
+     * @param id Node ID or Element object
+     */
+    node(id: string | Element | null): Element | null;
+    /**
+     * Ensure DOM element has an ID, auto-generates one if missing.
+     * Returns element's ID.
+     * @param node DOM element object
+     */
+    nodeId(node: HTMLElement): string;
+    /**
+     * Load modules using configured module loader.
+     * @param names Module names, supports string or string array
+     * @param callback Callback after modules are loaded
+     */
+    use(names: string | string[], callback?: (...modules: unknown[]) => void): void;
+    /**
+     * Protect object from direct modification in debug mode.
+     * Wraps data object with Proxy, intercepts read/write operations, warns to use State.set/digest for state management.
+     * Only effective when `window.__lark_Debug` is true.
+     * @param o Object to protect
+     */
+    guard<T extends object>(o: T): T;
+    /**
+     * Dynamically inject CSS styles into page. Returns cleanup function to remove injected styles.
+     * Supports single and batch injection.
+     * - `Framework.applyStyle("my-style", "body { color: red; }")` single injection
+     * - `Framework.applyStyle(["style1", "css1", "style2", "css2"])` batch injection
+     * @param styleIdOrPairs Style unique key or [id1, css1, id2, css2, ...] batch array
+     * @param cssText CSS style string (only used when first param is string)
+     */
+    applyStyle(styleIdOrPairs: string | string[], cssText?: string): () => void;
+    /**
+     * Generate globally unique identifier (GUID).
+     * @param prefix GUID prefix, defaults to "lark-"
+     */
+    guid(prefix?: string): string;
+    /**
+     * Create async callback validity marker.
+     * Returns a check function; if host object is unmarked (e.g., view re-rendered), check function returns false, preventing expired async callbacks from executing.
+     * Typical usage: `const check = Framework.mark(this, 'render'); setTimeout(() => { if (check()) ... })`
+     * @param host Host object (usually view instance)
+     * @param key Marker key name (usually "render" or specific async operation identifier)
+     */
+    mark(host: object, key: string): () => boolean;
+    /**
+     * Delay wait, Promise-based setTimeout wrapper.
+     * @param time Delay time in milliseconds
+     */
+    delay(time: number): Promise<void>;
+    /**
+     * Whether framework has booted
+     */
+    isBooted(): boolean;
+    /**
+     * Invalidate (unmark) async callback markers for a host object.
+     * Typically called when a view is re-rendered or destroyed.
+     * @param host The host object whose markers should be invalidated
+     */
+    unmark(host: object): void;
+    /**
+     * Fire a custom DOM event on a target element.
+     * @param target Target element or EventTarget
+     * @param eventType Event type string
+     * @param eventInit CustomEvent init options
+     */
+    dispatch(target: EventTarget, eventType: string, eventInit?: CustomEventInit): void;
+    /**
+     * Execute a function in try-catch with chunked scheduling.
+     * @param fn Function to execute
+     * @param args Arguments to pass
+     * @param context `this` context
+     */
+    task(fn: AnyFunc, args?: unknown[], context?: unknown): void;
+    /**
+     * Wait for all views in a zone to be rendered.
+     * Returns WAIT_OK if rendered, WAIT_TIMEOUT_OR_NOT_FOUND if timeout or not found.
+     * @param viewId Zone view ID
+     * @param timeout Timeout in milliseconds (default: 30000)
+     */
+    waitZoneViewsRendered(viewId: string, timeout?: number): Promise<number>;
+    /** Wait result: views rendered successfully */
+    WAIT_OK: number;
+    /** Wait result: timeout or view not found */
+    WAIT_TIMEOUT_OR_NOT_FOUND: number;
+    /**
+     * Base class with EventEmitter.
+     * Inherits EventEmitter for use as a base class in the framework.
+     */
+    Base: typeof EventEmitter;
+    /**
+     * View class.
+     * Use `View.extend()` to create subclasses.
+     */
+    View: typeof View;
+    /**
+     * Cache class.
+     * Use `new Cache()` to create cache instances.
+     */
+    Cache: typeof Cache;
+    /**
+     * Global state object.
+     */
+    State: StateInterface;
+    /**
+     * Router object.
+     */
+    Router: RouterInterface;
+    /**
+     * Frame class.
+     * Frame tree for view lifecycle management. Do not extend or instantiate directly.
+     */
+    Frame: typeof Frame;
+}
+/**
+ * Framework configuration interface, global config passed to app during `Framework.boot()`.
+ * All config items can be accessed at runtime via `Framework.config('key')`.
+ */
 interface FrameworkConfig {
-    /** Root element ID */
+    /**
+     * Root element ID.
+     * DOM root node ID where root view resides, framework renders root view within this node.
+     * This field is required, defaults to "root".
+     */
     rootId: string;
-    /** Default view path */
+    /**
+     * Default view path.
+     * Default root view path to load when URL doesn't match any route.
+     */
     defaultView?: string;
-    /** Default path when no hash present */
+    /**
+     * Default path when no hash present,
+     * Path used when URL hash is empty, defaults to "/".
+     */
     defaultPath?: string;
-    /** Route mapping: path -> view */
+    /**
+     * Route mapping: path -> view.
+     * Mapping relationship between paths and views.
+     * - Simple mapping: `{ "/home": "app/views/home" }`
+     * - Config mapping: `{ "/detail": { view: "app/views/detail", title: "Detail" } }`
+     * Use rewrite config item for path rewriting logic.
+     */
     routes?: Record<string, string | RouteViewConfig>;
     /** Hashbang prefix */
     hashbang?: string;
-    /** Error handler */
+    /**
+     * Error handler.
+     * Global error handling function, framework uses try-catch to execute some core logic.
+     * When errors are thrown, allows developers to catch them via this config item.
+     * Note: Do not re-throw any errors in this method.
+     */
     error?: (error: Error) => void;
-    /** Extensions to load */
-    exts?: string[];
+    /**
+     * Extensions to load.
+     * Array of extension view paths to load during app startup.
+     * These extension views are loaded before app initialization.
+     */
+    extensions?: string[];
     /** Init module to load */
-    ini?: string;
+    initModule?: string;
     /** Rewrite function for routes */
     rewrite?: (path: string, params: Record<string, string>, routes: Record<string, string>) => string;
-    /** Unmatched view (404) */
+    /**
+     * Unmatched view (404).
+     * View path to use when no matching view is found in routes, e.g., 404 page.
+     */
     unmatchedView?: string;
-    /** Module require function */
+    /**
+     * Module require function
+     */
     require?: (names: string[], params?: Record<string, unknown>) => Promise<unknown> | undefined;
     /** Skip view rendered check */
     skipViewRendered?: boolean;
-    /** Remold function for event processing */
-    remold?: (target: HTMLElement, type: string, event: Event) => boolean;
-    /** Dynamic config access */
+    /** Dynamic config access, custom config items */
     [key: string]: unknown;
 }
 interface RouteViewConfig {
@@ -333,7 +1434,7 @@ interface VdomElement extends Element {
 /** Element with frame binding */
 interface FrameBoundElement extends HTMLElement {
     /** Frame instance bound to this element */
-    frame?: FrameLike;
+    frame?: FrameInterface;
     /** Whether frame is bound (1 = bound) */
     frameBound?: number;
     /** View rendered flag */
@@ -343,6 +1444,15 @@ interface FrameBoundElement extends HTMLElement {
     /** Range element guid */
     rangeElementGuid?: number;
 }
+/** Options for compileTemplate() */
+interface CompileOptions {
+    /** Enable debug mode with line tracking (default: false) */
+    debug?: boolean;
+    /** Global variable names to destructure from $$ (refData) */
+    globalVars?: string[];
+    /** File path for debug error messages (default: undefined) */
+    file?: string;
+}
 
 /**
  * Lark framework utility functions.
@@ -350,8 +1460,6 @@ interface FrameBoundElement extends HTMLElement {
 
 /** 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 an array */
-declare const isArray: (arg: any) => arg is any[];
 /** 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) */
@@ -370,7 +1478,7 @@ declare function assign<T extends object>(target: T, ...sources: Partial<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;
+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.
@@ -417,7 +1525,7 @@ type Constructable = new (...args: never[]) => unknown;
  * This is the only place where we touch constructor internals -
  * it's a low-level framework utility for View.extend.
  */
-declare function classExtend<Proto extends object, Statics extends object>(ctor: Constructable, base: Constructable, props: Proto, statics: Statics): void;
+declare function classExtend<Proto extends object, Statics extends object>(make: Constructable, base: Constructable, props: Proto, statics: Statics): void;
 
 /** Internal splitter character (invisible, used as namespace separator) */
 declare const SPLITTER = "\u001E";
@@ -426,14 +1534,8 @@ declare const ROUTER_EVENTS: {
     CHANGED: string;
     PAGE_UNLOAD: string;
 };
-/** Attribute name: lark-key (static key for skipping VDOM diff) */
-declare const TAG_KEY = "lark-key";
-/** Attribute name: lark-attr-key (static attribute key) */
-declare const TAG_ATTR_KEY = "lark-attr-key";
-/** Attribute name: l (view key for assign) */
-declare const TAG_VIEW_KEY = "lark-view-key";
-/** Attribute name: lark-view */
-declare const LARK_VIEW = "lark-view";
+/** 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
@@ -483,400 +1585,49 @@ declare function mark$1(host: object, key: string): () => boolean;
 declare function unmark$1(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;
-
-/**
- * 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> {
-    /** 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.
-     */
-    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 least-used entries from cache */
-    private evictEntries;
-}
-
-/**
- * Multi-cast event emitter class.
- *
- * @example
- * const emitter = new EventEmitter();
- * emitter.on('change', (data) => console.log(data));
- * emitter.fire('change', { key: 'value' });
- */
-declare class EventEmitter {
-    /** Event listeners: prefixed key -> listener array */
-    private listeners;
-    /**
-     * Bind event listener.
-     */
-    on(event: string, handler: AnyFunc): this;
-    /**
-     * Unbind event listener.
-     * If handler is provided, removes only that handler.
-     * If no handler, removes all handlers for the event.
-     */
-    off(event: string, handler?: AnyFunc): this;
-    /**
-     * Fire event, execute all bound handlers.
-     * Supports executing state management: handlers removed during
-     * execution are safely handled.
-     *
-     * @param event - Event name
-     * @param data - Event data (type property added automatically)
-     * @param remove - Whether to remove all handlers after firing
-     * @param lastToFirst - Whether to execute handlers in reverse order
-     */
-    fire(event: string, data?: Record<string, unknown>, remove?: boolean, lastToFirst?: boolean): this;
-}
-
-/** Mark framework as booted (called from Framework.boot) */
-declare function markBooted(): void;
-/**
- * Observable in-memory data object.
- * Provides get/set/digest/diff/clean methods for cross-view data sharing.
- */
-declare const State: {
-    get<T = unknown>(key?: string): T;
-    set(data: Record<string, unknown>, excludes?: Set<string>): typeof State;
-    digest(data?: Record<string, unknown>, excludes?: Set<string>): void;
-    diff(): Readonly<Record<string, number>>;
-    clean(keys: string): {
-        ctor: AnyFunc;
-    };
-    on(event: string, handler: AnyFunc): typeof State;
-    off(event: string, handler?: AnyFunc): typeof State;
-    fire(event: string, data?: Record<string, unknown>, remove?: boolean): typeof State;
-};
-
-/**
- * Hash-based router with two-phase change confirmation.
- *
- * @example
- * Router.to('/list', { page: 2 });
- * const loc = Router.parse();
- * const diff = Router.diff();
- */
-declare const Router: {
-    /** Parse href into Location object */
-    parse(href?: string): Location;
-    /** Compute diff between current and previous location */
-    diff(): LocationDiff | undefined;
-    /** Navigate to new URL */
-    to(pathOrParams: string | Record<string, unknown>, params?: Record<string, unknown>, replace?: boolean, silent?: boolean): void;
-    /** Join path segments */
-    join(...paths: string[]): string;
-    /** Bind event listener */
-    on(event: string, handler: AnyFunc): typeof Router;
-    /** Unbind event listener */
-    off(event: string, handler?: AnyFunc): typeof Router;
-    /** Fire event */
-    fire(event: string, data?: Record<string, unknown>, remove?: boolean): typeof Router;
-    /** Internal: bind hashchange (called by Framework.boot) */
-    _bind(): void;
-    /** Internal: set framework config */
-    _setConfig(cfg: FrameworkConfig): void;
-    /** Internal: notify hash change (for programmatic trigger) */
-    notify?(e?: Event): void;
-};
-/** Mark framework as booted (called by Framework.boot) */
-declare function markRouterBooted(): void;
-
-/**
- * Base View class.
- * Views are created via View.extend() and mounted by Frame.
- *
- */
-declare class View {
-    /** View ID (same as owner frame ID) */
-    id: string;
-    /** Owner frame */
-    owner: FrameLike | number;
-    /** Updater instance */
-    updater: UpdaterLike;
-    /** Signature: > 0 means active, incremented on render, 0 = destroyed */
-    signature: number;
-    /** Whether rendered at least once */
-    rendered?: boolean;
-    /** Whether view has template */
-    template?: AnyFunc | string;
-    /** Location observation config */
-    locationObserved: ViewLocationObserved;
-    /** Observed state keys */
-    observedStateKeys?: string[];
-    /** Resource map */
-    resources: ViewResourceMap;
-    /** Selector event map: eventType -> handler name list */
-    eventSelectorMap: ViewEventSelectorMap;
-    /** Event object map: eventType -> bitmask */
-    eventObjectMap: ViewEventObjectMap;
-    /** Global event list */
-    globalEventList: ViewGlobalEventEntry[];
-    /** Assign method reference */
-    assignMethod?: AnyFunc;
-    /** Whether endUpdate pending */
-    endUpdatePending?: number;
-    /** Internal event storage */
-    private _events;
-    /**
-     * Initialize view (called by Frame when mounting).
-     */
-    init(): void;
-    /**
-     * Render view template (called by Frame after init).
-     * Wrapped by View_WrapMethod to manage signature + resources.
-     *
-     * Default implementation calls updater.digest() which:
-     * 1. Executes the template function with current data
-     * 2. Runs VDOM diff against previous DOM
-     * 3. Applies DOM operations
-     * 4. Calls endUpdate to mount child frames
-     *
-     */
-    render(): void;
-    on(event: string, handler: AnyFunc): this;
-    off(event: string, handler?: AnyFunc): this;
-    fire(event: string, data?: Record<string, unknown>, remove?: boolean, lastToFirst?: boolean): this;
-    /**
-     * Notify view that HTML update is about to begin.
-     * Unmounts child frames in the update zone.
-     */
-    beginUpdate(id?: string): void;
-    /**
-     * Notify view that HTML update has ended.
-     * Mounts child frames in the update zone and runs deferred invokes.
-     */
-    endUpdate(id?: string, inner?: boolean): void;
-    /**
-     * Wrap an async callback to check view signature before executing.
-     * If the view has been re-rendered or destroyed, the callback is skipped.
-     */
-    wrapAsync<Fn extends AnyFunc>(fn: Fn, context?: unknown): (...args: Parameters<Fn>) => ReturnType<Fn> | undefined;
-    /**
-     * Observe location parameters or path changes.
-     * When observed keys change, render() is called automatically.
-     */
-    observeLocation(params: string | string[] | Record<string, unknown>, observePath?: boolean): void;
-    /**
-     * Observe State data keys for changes.
-     * When observed keys change via State.digest(), render() is called.
-     */
-    observeState(observedKeys: string | string[]): void;
-    /**
-     * Capture (register) a resource under a key.
-     * If a resource already exists at that key, it's destroyed first.
-     * When destroyOnRender=true, the resource is destroyed on next render call.
-     */
-    capture(key: string, resource?: unknown, destroyOnRender?: boolean): unknown;
-    /**
-     * Release a captured resource.
-     * If destroy=true, calls the resource's destroy() method.
-     */
-    release(key: string, destroy?: boolean): unknown;
-    /**
-     * Set up a leave confirmation for route changes and page unload.
-     */
-    leaveTip(message: string, condition: () => boolean): void;
-    /** Collected ctors from mixins */
-    static ctors?: AnyFunc[];
-    /**
-     * Extend View to create a new View subclass.
-     *
-     * Supports:
-     * - props.ctor: constructor-like init (called with initParams + {node, deep})
-     * - props.mixins: array of mixin objects
-     * - Event method patterns: `'name<click>'` etc.
-     */
-    static extend(props?: ThisType<ViewInstance> & Record<string, unknown>, statics?: Record<string, unknown>): typeof View;
-    /**
-     * Merge mixins into View prototype.
-     */
-    static merge(...mixins: Record<string, unknown>[]): typeof View;
-}
-
+ * 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
+ */
 /**
- * Frame (View Frame) class for view lifecycle management.
- * Each frame owns a view and manages child frames.
+ * 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 class Frame extends EventEmitter implements FrameLike {
-    /** Frame ID (same as owner DOM element ID) */
-    readonly id: string;
-    /** Parent Frame ID */
-    private _parentId;
-    get parentId(): string | undefined;
-    /** Children map: id -> id */
-    childrenMap: FrameChildrenMap;
-    /** Children count */
-    childrenCount: number;
-    /** Ready count (children that have fired 'created') */
-    readyCount: number;
-    /** Ready map: id -> 1 */
-    readyMap: FrameReadyMap;
-    /** View instance */
-    viewInstance?: ViewInstance;
-    /** Get view instance (read-only) */
-    get view(): ViewInstance | undefined;
-    /** Invoke list for deferred method calls */
-    invokeList: FrameInvokeEntry[];
-    /** Signature for async operation tracking */
-    signature: number;
-    /** Whether view has altered */
-    hasAltered: number;
-    /** Whether view is destroyed */
-    destroyed: number;
-    /** View path (lark-view attribute value) */
-    viewPath?: string;
-    /** Original template before mount */
-    originalTemplate?: string;
-    /** Hold fire created flag */
-    holdFireCreated: number;
-    /** Children created flag */
-    childrenCreated: number;
-    /** Children alter flag */
-    childrenAlter: number;
-    constructor(id: string, parentId?: string);
-    /**
-     * Mount a view to this frame.
-     *
-     * Complete flow:
-     * 1. Parse viewPath, translate query params from parent
-     * 2. Unmount current view
-     * 3. Load View class (via require or provided ViewClass)
-     * 4. View_Prepare (scan event methods)
-     * 5. Create View instance
-     * 6. View_DelegateEvents (bind DOM events)
-     * 7. Call view.init()
-     * 8. If view has template, call render via Updater
-     * 9. If no template, call endUpdate directly
-     */
-    mountView(viewPath: string, viewInitParams?: Record<string, unknown>): void;
-    /**
-     * Internal: actually mount the view after class is loaded.
-     */
-    doMountView(ViewClass: typeof View, params: Record<string, string>, node: HTMLElement, sign: number): void;
-    /**
-     * Unmount current view.
-     */
-    unmountView(): void;
-    /**
-     * Mount a child frame.
-     */
-    mountFrame(frameId: string, viewPath: string, viewInitParams?: Record<string, unknown>): FrameLike;
-    /**
-     * Unmount a child frame.
-     */
-    unmountFrame(id?: string, _inner?: boolean): void;
-    /**
-     * Mount all views in a zone.
-     */
-    mountZone(zoneId?: string, _inner?: boolean): void;
-    /**
-     * Unmount all views in a zone.
-     */
-    unmountZone(zoneId?: string, _inner?: boolean): void;
-    /**
-     * Get all child frame IDs.
-     */
-    children(): string[];
-    /**
-     * Get parent frame at given level.
-     * @param level - How many levels up (default 1)
-     */
-    parent(level?: number): Frame | undefined;
-    /**
-     * Invoke a method on the view.
-     */
-    invoke(name: string, args?: unknown[]): unknown;
-    /** Get frame by ID */
-    static get(id: string): Frame | undefined;
-    /** Get all frames */
-    static getAll(): Map<string, Frame>;
-    /** Get or create root frame */
-    static root(rootId?: string): Frame;
-    /** Bind event listener (static) */
-    static on(event: string, handler: AnyFunc): typeof Frame;
-    /** Unbind event listener (static) */
-    static off(event: string, handler?: AnyFunc): typeof Frame;
-    /** Fire event (static) */
-    static fire(event: string, data?: Record<string, unknown>): void;
-}
+declare function safeguard<T>(data: T, getter?: ((key: string) => void) | null, setter?: ((path: string, value: unknown) => void) | null, isRoot?: boolean): T;
+
+/** Mark framework as booted (called from Framework.boot) */
+declare function markBooted(): void;
 /**
- * Register a View class for a given view path.
- * Called after module loading completes.
+ * Observable in-memory data object.
+ * Provides get/set/digest/diff/clean methods for cross-view data sharing.
  */
-declare function registerViewClass(viewPath: string, ViewClass: typeof View): void;
+declare const State: StateInterface;
+
+/**
+ * Hash-based router with two-phase change confirmation.
+ *
+ * @example
+ * Router.to('/list', { page: 2 });
+ * const loc = Router.parse();
+ * const diff = Router.diff();
+ */
+declare const Router: RouterInterface;
+/** Mark framework as booted (called by Framework.boot) */
+declare function markRouterBooted(): void;
 
 /**
  * Unmount frames within a DOM node.
  */
-declare function vdomUnmountFrames(frame: FrameLike, node: ChildNode): void;
+declare function vdomUnmountFrames(frame: FrameInterface, node: ChildNode): void;
 /**
  * Parse HTML string into a DOM element.
  * Handles special elements (table, SVG, MathML) with wrapper elements.
@@ -884,7 +1635,7 @@ declare function vdomUnmountFrames(frame: FrameLike, node: ChildNode): void;
 declare function vdomGetNode(html: string, refNode: Element): Element;
 /**
  * Get compare key for a DOM node (for keyed diff).
- * Uses id, lark-key (static key), or lark-view path.
+ * Uses id, ldk (static key), or v-lark path.
  */
 declare function vdomGetCompareKey(node: ChildNode): string | undefined;
 /**
@@ -898,11 +1649,11 @@ declare function vdomSetAttributes(oldNode: Element, newNode: Element, ref: VDom
 /**
  * Set child nodes from new parent onto old parent using keyed diff algorithm.
  */
-declare function vdomSetChildNodes(oldParent: Element, newParent: Element, ref: VDomRef, frame: FrameLike, keys_?: Record<string, number>): void;
+declare function vdomSetChildNodes(oldParent: Element, newParent: Element, ref: VDomRef, frame: FrameInterface, keys_?: Record<string, number>): void;
 /**
  * Diff two DOM nodes and apply changes.
  */
-declare function vdomSetNode(oldNode: ChildNode, newNode: ChildNode, oldParent: Element, ref: VDomRef, frame: FrameLike, keys_?: Record<string, number>): void;
+declare function vdomSetNode(oldNode: ChildNode, newNode: ChildNode, oldParent: Element, ref: VDomRef, frame: FrameInterface, keys_?: Record<string, number>): void;
 /**
  * Create an empty VDomRef for tracking diff operations.
  */
@@ -929,7 +1680,7 @@ declare function encodeQ(v: unknown): string;
  * Manages view-local data with change detection and VDOM diff triggering.
  *
  */
-declare class Updater implements UpdaterLike {
+declare class Updater implements UpdaterInterface {
     /** View ID (same as owner frame ID) */
     private viewId;
     /** Current data object */
@@ -994,257 +1745,199 @@ declare class Updater implements UpdaterLike {
 }
 
 /**
- * Bag wraps API response data with convenient access methods.
+ * Payload wraps API response data with convenient access methods.
  */
-declare class Bag {
-    /** Bag data */
+declare class Payload implements PayloadInterface {
+    /** Payload data */
     data: Record<string, unknown>;
     /** Internal cache info */
     cacheInfo?: ServiceCacheInfo;
     constructor(data?: Record<string, unknown>);
-    /** Get a value from bag data */
+    /** Get a value from payload data */
     get<T = unknown>(key: string): T;
-    /** Set a value in bag data */
-    set(keyOrData: string | Record<string, unknown> | ServiceMetaEntry, value?: unknown): this;
+    /** Set a value in payload data */
+    set(keyOrData: string | Record<string, unknown> | ServiceMetaEntry, value?: unknown): PayloadInterface;
 }
-interface ServiceConstructor {
-    new (): ServiceInstance;
-    add(attrs: ServiceMetaEntry | ServiceMetaEntry[]): void;
-    meta(attrs: string | Record<string, unknown>): ServiceMetaEntry;
-    create(attrs: Record<string, unknown>): Bag;
-    get(attrs: Record<string, unknown>, createNew?: boolean): {
-        entity: Bag;
-        needsUpdate: boolean;
+/**
+ * Minimal interface describing what serviceSend actually uses
+ * from a service instance. This avoids coupling to the full
+ * ServiceInterface which mixes instance and static methods.
+ */
+interface ServiceSendTarget {
+    destroyed: number;
+    busy: number;
+    internals: {
+        metaList: Record<string, ServiceMetaEntry>;
+        payloadCache: Cache<Payload>;
+        pendingCacheKeys: Record<string, PendingCacheEntry>;
+        syncFn: (payload: Payload, callback: () => void) => void;
+        staticEmitter: EventEmitter;
     };
-    cached(attrs: Record<string, unknown>): Bag | undefined;
-    clear(names: string | string[]): void;
-    on(event: string, handler: AnyFunc): void;
-    off(event: string, handler?: AnyFunc): void;
-    fire(event: string, data?: Record<string, unknown>): void;
-    extend(newSyncFn: (bag: Bag, callback: () => void) => void, newCacheMax?: number, newCacheBuffer?: number): ServiceConstructor;
-    _internals: ServiceInternals;
-}
-interface ServiceInstance {
-    id: string;
-    [key: string]: unknown;
-    _emitter: EventEmitter;
-    _internals: ServiceInternals;
-    _type: ServiceStaticsInternal;
-    all(attrs: string | Record<string, unknown> | (string | Record<string, unknown>)[], done: AnyFunc): ServiceInstance;
-    one(attrs: string | Record<string, unknown> | (string | Record<string, unknown>)[], done: AnyFunc): ServiceInstance;
-    save(attrs: string | Record<string, unknown> | (string | Record<string, unknown>)[], done: AnyFunc): ServiceInstance;
-    enqueue(callback: AnyFunc): ServiceInstance;
-    dequeue(...args: unknown[]): void;
-    destroy(): void;
-    on(event: string, handler: AnyFunc): ServiceInstance;
-    off(event: string, handler?: AnyFunc): ServiceInstance;
-    fire(event: string, data?: Record<string, unknown>): ServiceInstance;
-}
-interface ServiceInternals {
-    metas: Record<string, ServiceMetaEntry>;
-    bagCache: Cache<Bag>;
-    pendingCacheKeys: Record<string, PendingCacheEntry>;
-    syncFn: (bag: Bag, callback: () => void) => void;
-    staticEmitter: EventEmitter;
-}
-/** Internal type for serviceType object (static methods) */
-interface ServiceStaticsInternal {
-    add(attrs: ServiceMetaEntry | ServiceMetaEntry[]): void;
-    meta(attrs: string | Record<string, unknown>): ServiceMetaEntry;
-    create(attrs: Record<string, unknown>): Bag;
-    get(attrs: Record<string, unknown>, createNew?: boolean): {
-        entity: Bag;
-        needsUpdate: boolean;
+    type: {
+        get(attrs: Record<string, unknown>, createNew?: boolean): {
+            entity: Payload;
+            needsUpdate: boolean;
+        };
     };
-    cached(attrs: Record<string, unknown>): Bag | undefined;
-    clear(names: string | string[]): void;
-    on(event: string, handler: AnyFunc): void;
-    off(event: string, handler?: AnyFunc): void;
-    fire(event: string, data?: Record<string, unknown>): void;
-    extend(newSyncFn: (bag: Bag, callback: () => void) => void, newCacheMax?: number, newCacheBuffer?: number): ServiceConstructor;
+    enqueue(callback: AnyFunc): unknown;
 }
 /**
- * Default Service base class.
- * Use Service.extend() to create a usable subclass with a sync function.
- */
-declare const Service: ServiceConstructor;
-
-/**
- * DOM event delegation system.
- * Delegates events to document body for performance.
+ * Service: API request management with caching, deduplication, and queue.
  *
+ * - Service.extend(syncFn, cacheMax?, cacheBuffer?): creates subclass with sync function
+ * - Service.add(attrs): registers API endpoint metadata
+ * - new Service().all(attrs, done): fetch all, use cache when available
+ * - new Service().one(attrs, done): fetch all, callback on each completion
+ * - new Service().save(attrs, done): fetch all, skip cache (always request)
+ * - enqueue/dequeue: task queue for sequential async operations
+ * - destroy: cancel pending requests
+ *
+ * Per-type state (metaList, payloadCache, pendingCacheKeys, syncFn, staticEmitter)
+ * is stored as static class properties. When extend() creates a subclass,
+ * each subclass gets its own copies of these static properties, ensuring
+ * isolation between different Service types.
  */
-declare const EventDelegator: {
-    /**
-     * Bind a DOM event type to document body.
-     */
-    bind(eventType: string, hasSelector?: boolean): void;
-    /**
-     * Unbind a DOM event type from document body.
-     */
-    unbind(eventType: string, hasSelector?: boolean): void;
+declare class Service {
+    /** Service instance ID */
+    id: string;
+    /** Whether service is busy (1 = busy) */
+    busy: number;
+    /** Whether service is destroyed (1 = destroyed) */
+    destroyed: number;
+    /** Task queue for sequential operations */
+    taskQueue: AnyFunc[];
+    /** Previous dequeue arguments */
+    prevArgs: unknown[];
+    /** Instance event emitter */
+    private _emitter;
+    constructor();
+    /** Instance event emitter (public accessor) */
+    get emitter(): EventEmitterInterface;
     /**
-     * Clean up range events for a destroyed view.
+     * Get internals object for serviceSend compatibility.
+     * References per-type static state from the current class.
      */
-    clearRangeEvents(viewId: string): void;
+    get internals(): ServiceSendTarget["internals"];
     /**
-     * Set the frame getter function (called by Framework.boot).
+     * Get type reference (the constructor) for serviceSend compatibility.
+     * Static methods like get/create are accessible via the constructor.
      */
-    setFrameGetter(getter: (id: string) => FrameLike | undefined): void;
+    get type(): ServiceSendTarget["type"];
     /**
-     * Get next element GUID.
+     * Fetch all endpoints, callback when all complete.
+     * Uses cache when available.
      */
-    nextElementGuid(): number;
-};
-
-/**
- * Queue a function for deferred, chunked execution.
- *
- * @param fn - Function to execute (wrapped in try-catch automatically)
- * @param args - Arguments array to pass to the function
- * @param context - `this` context for the function call
- */
-declare function task(fn: AnyFunc, args?: unknown[], context?: unknown): void;
-/**
- * Fire a custom DOM event on a target element.
- */
-declare function dispatchEvent(target: EventTarget, eventType: string, eventInit?: CustomEventInit): void;
-/**
- * Base class that can be extended by any object needing EventEmitter.
- */
-declare class Base extends EventEmitter {
-}
-/**
- * Load modules via the configured require function.
- */
-declare function use(names: string | string[], callback?: (...modules: unknown[]) => void): void;
-/**
- * Wait for all views in a zone to be rendered.
- */
-declare function waitZoneViewsRendered(viewId: string, timeout?: number): Promise<number>;
-/**
- * Main framework object.
- * Provides boot, config, and all global utility methods.
- */
-declare const Framework: {
+    all(attrs: string | Record<string, unknown> | (string | Record<string, unknown>)[], done: AnyFunc): this;
     /**
-     * Get or set framework configuration.
+     * Fetch all endpoints, callback on each completion.
      */
-    config(cfg?: FrameworkConfig | string): FrameworkConfig | unknown;
+    one(attrs: string | Record<string, unknown> | (string | Record<string, unknown>)[], done: AnyFunc): this;
     /**
-     * Boot the framework.
+     * Fetch all endpoints, skip cache (always request).
      */
-    boot(cfg?: FrameworkConfig): void;
-    /** Whether framework has booted */
-    isBooted(): boolean;
-    /** Mark async callback validity tracker */
-    mark: typeof mark$1;
-    /** Unmark (invalidate) async callbacks */
-    unmark: typeof unmark$1;
-    /** Fire a custom DOM event on a target */
-    dispatch: typeof dispatchEvent;
-    /** Execute function in try-catch, ignoring errors */
-    task: typeof task;
-    /** Promise-based setTimeout */
-    delay(time: number): Promise<void>;
-    /** Load modules via configured require */
-    use: typeof use;
-    /** Wait for zone views to be rendered */
-    waitZoneViewsRendered: typeof waitZoneViewsRendered;
-    WAIT_OK: number;
-    WAIT_TIMEOUT_OR_UNFOUND: number;
+    save(attrs: string | Record<string, unknown> | (string | Record<string, unknown>)[], done: AnyFunc): this;
     /**
-     * Convert array to hash map.
+     * Enqueue a task for sequential execution.
      */
-    toMap: typeof toMap;
+    enqueue(callback: AnyFunc): this;
     /**
-     * Execute function in try-catch.
+     * Dequeue and execute the next task in queue.
      */
-    toTry: typeof funcWithTry;
+    dequeue(...args: unknown[]): void;
     /**
-     * Convert path + params to URL string.
+     * Destroy the service instance.
+     * After destruction, no new requests can be sent.
      */
-    toUrl: typeof toUri;
+    destroy(): void;
+    on(event: string, handler: AnyFunc): this;
+    off(event: string, handler?: AnyFunc): this;
+    fire(event: string, data?: Record<string, unknown>): this;
+    /** Per-type metadata registry */
+    static _metaList: Record<string, ServiceMetaEntry>;
+    /** Per-type payload cache (LFU with frequency eviction) */
+    static _payloadCache: Cache<Payload>;
+    /** Per-type pending cache keys for deduplication */
+    static _pendingCacheKeys: Record<string, PendingCacheEntry>;
+    /** Per-type sync function */
+    static _syncFn: (payload: Payload, callback: () => void) => void;
+    /** Per-type static event emitter */
+    static _staticEmitter: EventEmitter<unknown>;
+    /** Per-type cache max size */
+    static _cacheMax: number;
+    /** Per-type cache buffer size */
+    static _cacheBuffer: number;
     /**
-     * Parse URI string into path and params.
+     * Register API endpoint metadata.
      */
-    parseUrl: typeof parseUri;
+    static add(attrs: ServiceMetaEntry | ServiceMetaEntry[]): void;
     /**
-     * Mix properties from source to target.
+     * Get metadata for an API endpoint.
      */
-    mix: typeof assign;
+    static meta(attrs: string | Record<string, unknown>): ServiceMetaEntry;
     /**
-     * Check if object has own property.
+     * Create a Payload for an API request.
      */
-    has: typeof has;
+    static create(attrs: Record<string, unknown>): Payload;
     /**
-     * Get object keys.
+     * Get or create a Payload for an API request.
      */
-    keys: typeof keys;
+    static get(attrs: Record<string, unknown>, createNew?: boolean): {
+        entity: Payload;
+        needsUpdate: boolean;
+    };
     /**
-     * Check if node A is inside node B.
+     * Get cached Payload if available and not expired.
      */
-    inside: typeof nodeInside;
+    static cached(attrs: Record<string, unknown>): Payload | undefined;
     /**
-     * Get element by ID (shorthand for document.getElementById).
+     * Clear cached payloads by endpoint name.
      */
-    node: typeof getById;
+    static clear(names: string | string[]): void;
+    static on(event: string, handler: AnyFunc): void;
+    static off(event: string, handler?: AnyFunc): void;
+    static fire(event: string, data?: Record<string, unknown>): void;
     /**
-     * Apply CSS style.
+     * Create a new Service subclass with a custom sync function.
+     * Each subclass gets its own per-type state (metaList, cache, etc.)
+     * to ensure isolation between different Service types.
      */
-    applyStyle: typeof applyStyle;
+    static extend(newSyncFn: (payload: Payload, callback: () => void) => void, newCacheMax?: number, newCacheBuffer?: number): typeof Service;
+}
+
+/**
+ * DOM event delegation system.
+ * Delegates events to document body for performance.
+ *
+ */
+declare const EventDelegator: {
     /**
-     * Generate globally unique ID.
+     * Bind a DOM event type to document body.
      */
-    guid: typeof generateId;
+    bind(eventType: string, hasSelector?: boolean): void;
     /**
-     * Proxy-based debug guard.
+     * Unbind a DOM event type from document body.
      */
-    guard: typeof safeguard;
+    unbind(eventType: string, hasSelector?: boolean): void;
     /**
-     * Cache class.
+     * Clean up range events for a destroyed view.
      */
-    Cache: typeof Cache;
+    clearRangeEvents(viewId: string): void;
     /**
-     * Ensure element has an ID.
+     * Set the frame getter function (called by Framework.boot).
      */
-    nodeId(element: HTMLElement): string;
+    setFrameGetter(getter: (id: string) => FrameInterface | undefined): void;
     /**
-     * Base class with EventEmitter.
+     * Get next element GUID.
      */
-    Base: typeof Base;
-    /** Router module */
-    Router: {
-        parse(href?: string): Location;
-        diff(): LocationDiff | undefined;
-        to(pathOrParams: string | Record<string, unknown>, params?: Record<string, unknown>, replace?: boolean, silent?: boolean): void;
-        join(...paths: string[]): string;
-        on(event: string, handler: AnyFunc): typeof Router;
-        off(event: string, handler?: AnyFunc): typeof Router;
-        fire(event: string, data?: Record<string, unknown>, remove?: boolean): typeof Router;
-        _bind(): void;
-        _setConfig(cfg: FrameworkConfig): void;
-        notify?(e?: Event): void;
-    };
-    /** State module */
-    State: {
-        get<T = unknown>(key?: string): T;
-        set(data: Record<string, unknown>, excludes?: Set<string>): typeof State;
-        digest(data?: Record<string, unknown>, excludes?: Set<string>): void;
-        diff(): Readonly<Record<string, number>>;
-        clean(keys: string): {
-            ctor: AnyFunc;
-        };
-        on(event: string, handler: AnyFunc): typeof State;
-        off(event: string, handler?: AnyFunc): typeof State;
-        fire(event: string, data?: Record<string, unknown>, remove?: boolean): typeof State;
-    };
-    /** View class */
-    View: typeof View;
-    /** Frame class */
-    Frame: typeof Frame;
+    nextElementGuid(): number;
 };
 
+/**
+ * Main framework object.
+ * Provides boot, config, and all global utility methods.
+ */
+declare const Framework: FrameworkInterface;
+
 /**
  * @lark/framework Store
  *
@@ -1258,8 +1951,6 @@ declare const Framework: {
  * - cell/observeCell: lightweight standalone reactive cells
  */
 
-/** Reactive proxy object — all string keys map to unknown values */
-type ProxyObject = Record<string, unknown>;
 interface Task {
     cb: AnyFunc;
     params?: Record<string, unknown>;
@@ -1310,10 +2001,10 @@ declare class Queue {
 declare const isState: (target: unknown) => boolean;
 declare const mark: (host: Record<string, unknown>, key: string) => (() => boolean);
 declare const unmark: (host: Record<string, unknown>) => void;
-declare function createState(initialData: unknown, config?: StateConfig): ProxyObject;
-declare function lazySet(target: ProxyObject, data: Record<string, unknown>): void;
+declare function createState(initialData: unknown, config?: StateConfig): Record<string, unknown>;
+declare function lazySet(target: Record<string, unknown>, data: Record<string, unknown>): void;
 /** Shallow set: only top-level properties are reactive */
-declare function shallowSet(target: ProxyObject, key: string, data: unknown): unknown;
+declare function shallowSet(target: Record<string, unknown>, key: string, data: unknown): unknown;
 declare const _storeName: unique symbol;
 declare const _storeStatus: unique symbol;
 declare const _storeScheduler: unique symbol;
@@ -1333,10 +2024,10 @@ declare abstract class BaseStore {
     [_storeScheduler]: Scheduler;
     [_originState]: Record<string, unknown>;
     [_stateKeys]: string[];
-    [_storeState]: ProxyObject;
+    [_storeState]: Record<string, unknown>;
     [_storeDefScheduler]: () => Queue;
     private [_outerStore];
-    [_storeBoot](): ProxyObject;
+    [_storeBoot](): Record<string, unknown>;
     [_storeDestroy](): void;
     /**
      *
@@ -1345,11 +2036,11 @@ declare abstract class BaseStore {
      */
     [_storeCreate](body: Record<string, unknown>, excludeFns?: string[]): void;
     constructor(name: string, config?: StoreConfig);
-    [_innerStore](): ProxyObject;
+    [_innerStore](): Record<string, unknown>;
     get status(): StoreStatus;
     get storeName(): string;
     get scheduler(): Scheduler;
-    [_storeProxy](toOut?: boolean): ProxyObject;
+    [_storeProxy](toOut?: boolean): Record<string, unknown>;
 }
 interface LarkView {
     updater: {
@@ -1390,23 +2081,89 @@ declare function getUseStore(name: string): AnyFunc | undefined;
 declare function cloneStore(name: string, useStore: AnyFunc, config?: StoreConfig): unknown;
 declare function isStoreActive(name: string): boolean;
 declare function cell<T = unknown>(data: T): T;
-declare function observeCell(state: ProxyObject, cb: AnyFunc, immediate?: boolean): () => void;
+declare function observeCell(state: Record<string, unknown>, cb: AnyFunc, immediate?: boolean): () => void;
 declare function multi<S = Record<string, unknown>>(useStore: LarkUseStore<S>): [LarkUseStore<S>, {
-    ctor: AnyFunc;
+    make: AnyFunc;
 }];
 
+/** 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;
+}
+/** 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;
+}
+/**
+ * Serialize the entire Frame tree starting from root.
+ */
+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;
+
 /**
  * @lark/framework Template Compiler
  *
  *   convertArtSyntax()    ({{}} → <% %>)
- *   processViewEvents()      (v-event prefix + param encoding)
+ *   processViewEvents()      (@event prefix + param encoding)
  *   compileToFunction()  (<% %> → JS template function)
  *   extractGlobalVars()   (AST-based global var analysis via @babel/parser)
  *
  * - All template operators: = (escape), ! (raw), @ (ref lookup), : (binding)
- * - v-event attribute processing with $g prefix + \x1e separator
- * - $n (null-safe toString), $e (HTML entity encode), $eu (URI encode), $eq (quote encode), $i (ref lookup)
- * - Debug mode with line tracking ($expr/$art/$line) and try-catch error wrapper
+ * - @event attribute processing with $splitter prefix + \x1e separator
+ * - $strSafe (null-safe toString), $encHtml (HTML entity encode), $encUri (URI encode), $encQuote (quote encode), $refFn (ref lookup)
+ * - Debug mode with line tracking ($dbgExpr/$dbgArt/$dbgLine) and try-catch error wrapper
  * - View ID injection (\x1f → '+$viewId+')
  * - Post-processing cleanup of empty concatenations
  * - 0 configuration: auto-extract variables via AST analysis
@@ -1416,25 +2173,17 @@ declare function multi<S = Record<string, unknown>>(useStore: LarkUseStore<S>):
  *   {{:variable}}              → two-way binding (same as = for rendering)
  *   {{!variable}}              → raw output (no HTML escaping)
  *   {{@variable}}              → reference lookup for component data passing
- *   {{each list as item}}      → loop
- *   {{each list as item idx}}  → loop with index
- *   {{parse obj as val key}}   → object iteration
+ *   {{forOf list as item}}      → loop
+ *   {{forOf list as item idx}}  → loop with index
+ *   {{forIn obj as val key}}   → object iteration
  *   {{for(let i=0;i<n;i++)}}  → generic for loop
  *   {{if condition}}           → conditional
  *   {{else if condition}}      → else-if
  *   {{else}}                   → else
- *   {{/if}} / {{/each}} / {{/parse}} / {{/for}} → close blocks
+ *   {{/if}} / {{/forOf}} / {{/forIn}} / {{/for}} → close blocks
  *   {{set a = b}}              → variable declaration
  */
-/** Options for compileTemplate() */
-interface CompileOptions {
-    /** Enable debug mode with line tracking (default: false) */
-    debug?: boolean;
-    /** Global variable names to destructure from $$ (refData) */
-    globalVars?: string[];
-    /** File path for debug error messages (default: undefined) */
-    file?: string;
-}
+
 /**
  * Compile an HTML template string into a JS module string.
  * This is the main entry point for both Vite and Webpack loaders.
@@ -1443,7 +2192,7 @@ interface CompileOptions {
  *   (data, selfId, refData) => string
  *
  * Internally it calls the compiled template function with the standard
- * signature: ($$,$viewId,$$ref,$e,$n,$eu,$i,$eq)
+ * signature: ($data,$viewId,$refAlt,$encHtml,$strSafe,$encUri,$refFn,$encQuote)
  *
  * @param source - The raw HTML template content
  * @param options - Compilation options
@@ -1468,4 +2217,4 @@ declare function compileTemplate(source: string, options?: CompileOptions): stri
  */
 declare function extractGlobalVars(source: string): string[];
 
-export { type AnyFunc, Bag, type BagEntry, CALL_BREAK_TIME, Cache, type CacheEntry, type CacheOptions, type CompileOptions, type Constructable, EVENT_METHOD_REGEXP, EventDelegator, EventEmitter, type EventListenerEntry, Frame, type FrameBoundElement, type FrameChildrenMap, type FrameInvokeEntry, type FrameLike, type FrameReadyMap, Framework, type FrameworkConfig, LARK_VIEW, type LarkUseStore, type Location, type LocationDiff, type MixinEventHandler, type NodeUseStore, type ObservePayload, type ParamDiff, type ParsedUri, type PendingCacheEntry, Platform, ROUTER_EVENTS, type ReactUseStore, type RouteViewConfig, Router, SPLITTER, Service, type ServiceCacheInfo, type ServiceConstructor, type ServiceEntry, type ServiceMetaEntry, type ServiceOptions, State, type StoreConfig, type StoreMethods, TAG_ATTR_KEY, TAG_KEY, TAG_NAME_REGEXP, TAG_VIEW_KEY, Updater, type UpdaterLike, type VDomOp, type VDomRef, VIEW_EVENT_METHOD_REGEXP, type VdomElement, View, type ViewClassInternal, type ViewEventObjectMap, type ViewEventSelectorEntry, type ViewEventSelectorMap, type ViewGlobalEventEntry, type ViewInstance, type ViewLocationObserved, type ViewResourceEntry, type ViewResourceMap, type VoidFunc, applyIdUpdates, applyStyle, applyVdomOps, assign, cell, classExtend, cloneData, cloneStore, compileTemplate, createState, createVdomRef, defineStore, delStore, encodeHTML, encodeQ, encodeSafe, encodeURIExtra, ensureElementId, extractGlobalVars, funcWithTry, generateId, getAttribute, getById, getPlatform, getStore, getUseStore, has, isArray, isPlainObject, isPrimitive, isPrimitiveOrFunc, isState, isStoreActive, keys, lazySet, mark$1 as mark, markBooted, markRouterBooted, multi, nextCounter, nodeInside, noop, now, observeCell, parseUri, registerViewClass, safeguard, setData, shallowSet, mark as storeMark, unmark as storeUnmark, syncCounter, toMap, toUri, translateData, unmark$1 as unmark, vdomGetCompareKey, vdomGetNode, vdomSetAttributes, vdomSetChildNodes, vdomSetNode, vdomSpecialDiff, vdomUnmountFrames };
+export { CALL_BREAK_TIME, Cache, type CacheEntry, type CacheOptions, type CompileOptions, type Constructable, EVENT_METHOD_REGEXP, EventDelegator, EventEmitter, type EventListenerEntry, Frame, type FrameBoundElement, type FrameInterface, type FrameInvokeEntry, Framework, type FrameworkConfig, LARK_VIEW, type LarkUseStore, type Location, type LocationDiff, type MixinEventHandler, type NodeUseStore, type ObservePayload, type ParamDiff, type ParsedUri, Payload, type PayloadEntry, type PendingCacheEntry, Platform, ROUTER_EVENTS, type ReactUseStore, type RouteViewConfig, Router, SPLITTER, type SerializedFrameNode, type SerializedFrameTree, type SerializedViewInfo, Service, type ServiceCacheInfo, type ServiceEntry, type ServiceMetaEntry, type ServiceOptions, State, type StoreConfig, type StoreMethods, TAG_NAME_REGEXP, Updater, type UpdaterInterface, type VDomOp, type VDomRef, VIEW_EVENT_METHOD_REGEXP, type VdomElement, View, type ViewEventSelectorEntry, type ViewGlobalEventEntry, type ViewInterface, type ViewLocationObserved, type ViewResourceEntry, applyIdUpdates, applyStyle, applyVdomOps, assign, cell, classExtend, cloneData, cloneStore, compileTemplate, createState, createVdomRef, defineStore, delStore, encodeHTML, encodeQ, encodeSafe, encodeURIExtra, ensureElementId, extractGlobalVars, funcWithTry, generateId, getAttribute, getById, getPlatform, getStore, getUseStore, has, installFrameVisualizerBridge, isPlainObject, isPrimitive, isPrimitiveOrFunc, isState, isStoreActive, keys, lazySet, mark$1 as mark, markBooted, markRouterBooted, multi, nextCounter, nodeInside, noop, now, observeCell, parseUri, registerViewClass, safeguard, serializeFrameTree, setData, shallowSet, mark as storeMark, unmark as storeUnmark, syncCounter, toMap, toUri, translateData, unmark$1 as unmark, vdomGetCompareKey, vdomGetNode, vdomSetAttributes, vdomSetChildNodes, vdomSetNode, vdomSpecialDiff, vdomUnmountFrames };