@lark.js/mvc 0.0.3 → 0.0.4

package/dist/index.d.ts

@@ -1,876 +1,1633 @@
 /**
- * Lark framework type definitions.
- * All shared types are defined here to eliminate type cheats across modules.
- */
-/** Generic function type for event handlers and callbacks.
- *  Uses any[] to accept callbacks with specific parameter types
- *  (TypeScript function parameters are contravariant).
+ * Base View class.
+ * Views are created via View.extend() and mounted by Frame.
  */
-type AnyFunc = (...args: any[]) => unknown;
-/** A function that returns void. */
-type VoidFunc = (...args: any[]) => void;
-interface CacheEntry<T> {
-    /** Original key without prefix */
-    originalKey: string;
-    /** Cached value */
-    value: T | undefined;
-    /** Access frequency count */
-    frequency: number;
-    /** Last access timestamp */
-    lastTimestamp: number;
-}
-interface CacheOptions<T> {
-    /** Maximum cache size before eviction triggers (default: 20) */
-    maxSize?: number;
-    /** Buffer size for eviction (default: 5) */
-    bufferSize?: number;
-    /** Callback when entry is removed */
-    onRemove?: (key: string) => void;
-    /** Comparator for sorting entries */
-    sortComparator?: (a: CacheEntry<T>, b: CacheEntry<T>) => number;
-}
-interface EventListenerEntry {
-    /** Handler function */
-    handler: AnyFunc;
-    /** Whether currently executing (1 = executing, '' = done) */
-    executing: number | string;
-}
-interface ParsedUri {
-    /** Path portion (before ? or #) */
-    path: string;
-    /** Key-value params */
-    params: Record<string, string>;
-}
-interface Location {
-    /** Full href */
-    href: string;
-    /** Query string (before #) */
-    srcQuery: string;
-    /** Hash string (after #) */
-    srcHash: string;
-    /** Parsed query object */
-    query: ParsedUri;
-    /** Parsed hash object */
-    hash: ParsedUri;
-    /** Merged params from query and hash */
-    params: Record<string, string>;
-    /** Resolved view path */
-    view?: string;
-    /** Resolved path */
-    path?: string;
-    /** Get param by key with optional default */
-    get: (key: string, defaultValue?: string) => string;
-}
-interface ParamDiff {
-    from: string;
-    to: string;
-}
-interface LocationDiff {
-    /** Changed params (key -> {from, to}) */
-    params: Record<string, ParamDiff>;
-    /** Whether path changed */
-    path?: ParamDiff;
-    /** Whether view changed */
-    view?: ParamDiff;
-    /** Whether this is a first forced change */
-    force: boolean;
-    /** Whether anything changed */
-    changed: boolean;
-}
-interface VDomRef {
-    /** ID update list: [element, newId][] */
-    idUpdates: [Element, string][];
-    /** Views that need post-processing */
-    views: ViewInstance[];
-    /** 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 */
-    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;
-}
-/** View event selector map entry: handler name list with selector presence tracking */
-interface ViewEventSelectorEntry {
-    /** Selector name list */
-    selectors: string[];
-    /** 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;
-    /** Keys to observe */
-    keys: string[];
-    /** Whether observing path */
-    observePath: boolean;
-}
-interface ViewResourceEntry {
-    /** The resource entity */
-    entity: unknown;
-    /** 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;
-    /** Bound handler wrapper (for removeEventListener) */
-    boundHandler?: AnyFunc;
-    /** DOM element (window/document) */
-    element: EventTarget;
-    /** Event name */
-    eventName: string;
-    /** Modifiers */
-    modifiers: Record<string, boolean>;
-}
-type ViewEventObjectMap = Record<string, number>;
-interface ViewInstance {
+declare class View implements ViewInterface {
     /** View ID (same as owner frame ID) */
     id: string;
     /** Owner frame */
-    owner: FrameLike | number;
+    owner: FrameInterface | number;
     /** Updater instance */
-    updater: UpdaterLike;
+    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;
+    template?: (data: unknown, viewId: string, refData: unknown, ...rest: unknown[]) => string | string;
     /** Location observation config */
     locationObserved: ViewLocationObserved;
     /** Observed state keys */
     observedStateKeys?: string[];
     /** Resource map */
-    resources: ViewResourceMap;
-    /** Selector event map: eventType -> selector list */
-    eventSelectorMap: ViewEventSelectorMap;
-    /** Event object map: eventType -> bitmask */
-    eventObjectMap: ViewEventObjectMap;
-    /** Global event list */
-    globalEventList: ViewGlobalEventEntry[];
+    resources: Record<string, ViewResourceEntry>;
     /** Assign method reference */
     assignMethod?: AnyFunc;
-    /** Whether endUpdate has been called (1 = pending) */
+    /** Whether endUpdate pending */
     endUpdatePending?: number;
-    /** Render method (wrapped) */
-    render: AnyFunc;
-    /** init method */
-    init: AnyFunc;
-    /** Wrapped render method */
-    $b?: 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;
-    beginUpdate: (id?: string) => void;
-    endUpdate: (id?: string, inner?: boolean) => void;
-    wrapAsync: <Fn extends AnyFunc>(fn: Fn, context?: unknown) => (...args: Parameters<Fn>) => ReturnType<Fn> | undefined;
-    observeLocation: (params: string | string[] | Record<string, unknown>, observePath?: boolean) => void;
-    observeState: (keys: string | string[]) => void;
-    capture: (key: string, resource?: unknown, destroyOnRender?: boolean) => unknown;
-    release: (key: string, destroy?: boolean) => unknown;
-    leaveTip: (message: string, condition: () => boolean) => void;
-    assign: (options?: unknown) => boolean | undefined;
-}
-/** Minimal Frame interface needed by View */
-interface FrameLike {
-    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;
-    unmountFrame: (id?: string, inner?: boolean) => void;
-    view: ViewInstance | undefined;
-    children: () => string[];
-    invoke: (name: string, args?: unknown[]) => unknown;
-    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 {
-    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 */
-    altered: () => boolean | undefined;
-    /** Ref data for template rendering */
-    refData: Record<string, unknown>;
-}
-interface ServiceOptions {
-    /** Request URL */
-    url: string;
-    /** Request params */
-    params?: Record<string, unknown>;
-    /** HTTP method */
-    method?: "GET" | "POST" | "PUT" | "DELETE";
-    /** Cache: true for default, number for TTL */
-    cache?: boolean | number;
-    /** POST data */
-    data?: unknown;
-}
-interface BagEntry {
-    /** Bag data */
-    data: Record<string, unknown>;
-}
-interface ServiceEntry {
-    /** Service ID */
-    id: string;
-    /** Service URL */
-    url: string;
-    /** Cache time in ms, 0 = no cache */
-    cacheTime: number;
-    /** Bag instance */
-    bag?: BagEntry;
-    /** Whether loading */
-    loading?: boolean;
-    /** Error info */
-    error?: Error;
-}
-/** Pending cache entry for deduplication (internal to Service) */
-interface PendingCacheEntry extends Array<unknown> {
-    /** Reference to the pending Bag entity */
-    e?: unknown;
-}
-interface ServiceMetaEntry {
-    /** Endpoint name */
-    name: string;
-    /** URL */
-    url: string;
-    /** Cache TTL in ms, 0 = no cache */
-    cache?: number;
-    /** Before-fetch hook */
-    before?: AnyFunc;
-    /** After-fetch hook */
-    after?: AnyFunc;
-    /** Clean keys on destroy */
-    cleans?: string;
-    /** Additional properties */
-    [key: string]: unknown;
-}
-/** Cache info attached to Bag entity */
-interface ServiceCacheInfo {
-    /** Endpoint name */
-    name: string;
-    /** After-fetch hook */
-    after?: AnyFunc | undefined;
-    /** Clean keys */
-    cleans?: string | undefined;
-    /** Cache key */
-    key: string;
-    /** Timestamp when cached */
-    time: number;
-}
-interface FrameworkConfig {
-    /** Root element ID */
-    rootId: string;
-    /** Default view path */
-    defaultView?: string;
-    /** Default path when no hash present */
-    defaultPath?: string;
-    /** Route mapping: path -> view */
-    routes?: Record<string, string | RouteViewConfig>;
-    /** Hashbang prefix */
-    hashbang?: string;
-    /** Error handler */
-    error?: (error: Error) => void;
-    /** Extensions to load */
-    exts?: string[];
-    /** Init module to load */
-    ini?: string;
-    /** Rewrite function for routes */
-    rewrite?: (path: string, params: Record<string, string>, routes: Record<string, string>) => string;
-    /** Unmatched view (404) */
-    unmatchedView?: string;
-    /** 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 */
-    [key: string]: unknown;
-}
-interface RouteViewConfig {
-    /** View path */
-    view: string;
-    /** Additional properties merged into location */
-    [key: string]: unknown;
-}
-/** Element with VDOM diff cached compare key */
-interface VdomElement extends Element {
-    /** Whether compare key is cached */
-    compareKeyCached?: number | undefined;
-    /** Cached compare key */
-    cachedCompareKey?: string | undefined;
-    /** Whether auto-generated ID */
-    autoId?: number;
-}
-/** Element with frame binding */
-interface FrameBoundElement extends HTMLElement {
-    /** Frame instance bound to this element */
-    frame?: FrameLike;
-    /** Whether frame is bound (1 = bound) */
-    frameBound?: number;
-    /** View rendered flag */
-    viewRendered?: number;
-    /** Range frame ID */
-    rangeFrameId?: string;
-    /** Range element guid */
-    rangeElementGuid?: 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;
 }
 
 /**
- * Lark framework utility functions.
+ * 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;
+}
 
-/** 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) */
-declare function isPrimitive(value: unknown): boolean;
-declare function generateId(prefix?: string): string;
-/** Sync local counter with global counter */
-declare function syncCounter(val: number): void;
-declare function noop(): void;
-/** Safe hasOwnProperty check */
-declare function has<T extends object>(owner: T | undefined | null, prop: PropertyKey): boolean;
-/** Get object keys (own enumerable) */
-declare function keys<T extends object>(obj: T): string[];
-/** Assign properties from sources to target (like Object.assign but safer) */
-declare function assign<T extends object>(target: T, ...sources: Partial<T>[]): T;
 /**
- * Execute functions in try-catch, ignoring errors.
- * Returns the result of the last successfully executed function.
+ * Frame (View Frame) class for view lifecycle management.
+ * Each frame owns a view and manages child frames.
+ *
  */
-declare function funcWithTry(fns: AnyFunc | AnyFunc[], args: unknown[], context: unknown, configError: (e: unknown) => void): unknown;
+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;
+}
 /**
- * Set newData into oldData, tracking changed keys.
- * Returns whether any value changed.
+ * Register a View class for a given view path.
+ * Called after module loading completes.
  */
-declare function setData(newData: Record<string, unknown>, oldData: Record<string, unknown>, changedKeys: Record<string, number>, excludes: Set<string>): boolean;
+declare function registerViewClass(viewPath: string, ViewClass: typeof View): void;
+
 /**
- * Translate data references: if a value starts with SPLITTER, replace it
- * with the corresponding value from the data object.
+ * 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 function translateData(data: object, value: unknown): unknown;
-/** Get element by ID, or return the element itself if already an element */
-declare function getById(id: string | Element | null): Element | null;
-/** Get attribute from element safely */
-declare function getAttribute(element: Element, attr: string): string;
-/** Ensure element has an ID, generating one if missing. Returns the ID. */
-declare function ensureElementId(element: HTMLElement): string;
+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;
+}
+
 /**
- * Check if node A is inside node B (or is the same node).
- * Uses compareDocumentPosition for efficiency.
+ * 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.
  */
-declare function nodeInside(a: string | HTMLElement, b: string | HTMLElement): boolean;
-/**
- * Parse URI string into path and params object.
- * e.g. "/xxx/?a=b&c=d" => { path: "/xxx/", params: { a: "b", c: "d" } }
+/** Generic function type for event handlers and callbacks.
+ *  Uses any[] to accept callbacks with specific parameter types
+ *  (TypeScript function parameters are contravariant).
  */
-declare function parseUri(uri: string): ParsedUri;
+type AnyFunc = (...args: any[]) => unknown;
+interface CacheEntry<T> {
+    /** Original key without prefix */
+    originalKey: string;
+    /** Cached value */
+    value: T | undefined;
+    /** Access frequency count */
+    frequency: number;
+    /** Last access timestamp */
+    lastTimestamp: number;
+}
+interface CacheOptions<T> {
+    /** Maximum cache size before eviction triggers (default: 20) */
+    maxSize?: number;
+    /** Buffer size for eviction (default: 5) */
+    bufferSize?: number;
+    /** Callback when entry is removed */
+    onRemove?: (key: string) => void;
+    /** Comparator for sorting entries */
+    sortComparator?: (a: CacheEntry<T>, b: CacheEntry<T>) => number;
+}
 /**
- * Convert path and params to URI string.
- * e.g. toUri("/xxx/", { a: "b", c: "d" }) => "/xxx/?a=b&c=d"
+ * Cache interface providing LFU (Least Frequently Used) cache management.
+ * Cache keys use a special prefix internally for namespace isolation.
  */
-declare function toUri(path: string, params: Record<string, unknown>, keepEmptyObject?: Record<string, number>): string;
+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;
+}
 /**
- * Convert array to map/hash object.
- * For simple arrays, counts occurrences.
- * For object arrays, uses specified key as map key.
+ * Parsed URL result containing path and parameters.
+ * Returned by `Router.parse()`, includes the path string and parsed key-value parameter pairs.
  */
-declare function toMap<T>(list: T[] | null | undefined, key?: keyof T): Record<string, T | number>;
-/** Get current timestamp */
-declare function now(): number;
-/** Constructable function type */
-type Constructable = new (...args: never[]) => unknown;
+interface ParsedUri {
+    /** Path portion (before ? or #), excluding query parameters */
+    path: string;
+    /** Key-value params parsed from the URL */
+    params: Record<string, string>;
+}
 /**
- * Implement classical inheritance with prototype chain.
- * This is the only place where we touch constructor internals -
- * it's a low-level framework utility for View.extend.
+ * Current URL parsing result interface.
+ * Returned by `Router.parse()`, includes both query (after ?) and hash (after #) sections.
  */
-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";
-declare const ROUTER_EVENTS: {
-    CHANGE: string;
-    CHANGED: string;
-    PAGE_UNLOAD: string;
-};
-/** Attribute name: v-lark */
-declare const LARK_VIEW = "v-lark";
-/** View event method regex: e.g. "app\x1eclickHandler(click)" or "clickHandler()"
- * Group 1: optional frame ID (before SPLITTER)
- * Group 2: handler name
- * Group 3: params string
+interface Location {
+    /** Full href, original href string */
+    href: string;
+    /** Query string (before #), raw query string (after ?, before #) */
+    srcQuery: string;
+    /** Hash string (after #), raw hash string (after #) */
+    srcHash: string;
+    /** Parsed query object, path and params parsed from srcQuery */
+    query: ParsedUri;
+    /** Parsed hash object, path and params parsed from srcHash */
+    hash: ParsedUri;
+    /**
+     * Merged params from query and hash,
+     * hash values take precedence when keys conflict.
+     */
+    params: Record<string, string>;
+    /**
+     * Resolved view path for the current URL.
+     * May be undefined before framework boot.
+     */
+    view?: string;
+    /**
+     * 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 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.
  */
-declare const EVENT_METHOD_REGEXP: RegExp;
-/** View event method name regex: e.g. "name<click,mousedown>" or "$selector<click>" */
-declare const VIEW_EVENT_METHOD_REGEXP: RegExp;
-/** Tag name regexp for I_GetNode */
-declare const TAG_NAME_REGEXP: RegExp;
-/** Async task break time (ms) */
-declare const CALL_BREAK_TIME = 48;
-/** Increment global counter and return new value */
-declare function nextCounter(): number;
-
+interface ParamDiff {
+    /** Value before the change */
+    from: string;
+    /** Value after the change */
+    to: string;
+}
 /**
- * Dynamically inject CSS styles into the document head.
- * Returns a cleanup function to remove the injected styles.
- *
- * @param styleIdOrPairs - Style ID string or array of [id, content] pairs
- * @param css - CSS content string (only used when first arg is string)
- * @returns Cleanup function to remove the styles
+ * URL route change object interface describing changes between two routing states.
+ * Returned by `Router.diff()`, includes changes in path, view, and other parameters.
  */
-declare function applyStyle(styleIdOrPairs: string | string[], css?: string): () => void;
-
+interface LocationDiff {
+    /**
+     * Changed params (key -> {from, to}),
+     * diff for all changed parameters
+     */
+    params: Record<string, ParamDiff>;
+    /** Path diff when path has changed */
+    path?: ParamDiff;
+    /** View diff when rendered view has changed */
+    view?: ParamDiff;
+    /**
+     * Whether this is a first forced change during app initialization.
+     */
+    force: boolean;
+    /** Whether any content has changed */
+    changed: boolean;
+}
 /**
- * Mark/Unmark: signature-based lifecycle tracking for async callbacks.
- *
- * mark() returns a validity checker function. If the host is "unmarked"
- * (e.g. view re-rendered), the checker returns false, preventing stale callbacks.
+ * 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;
+}
 /**
- * Create a mark for tracking async callback validity.
- * Returns a function that checks if the mark is still valid.
- *
- * @param host - Object to store mark state on (typically a view)
- * @param key - Key to track (typically "render" or specific async operation)
- * @returns Checker function that returns true if mark is still valid
+ * Route post-change event interface (changed phase).
+ * Carries route diff information. Triggered after route change is confirmed and URL is updated.
  */
-declare function mark$1(host: object, key: string): () => boolean;
+type RouteChangedEvent = LocationDiff & ChangeEvent;
+interface VDomRef {
+    /** ID update list: [element, newId][] */
+    idUpdates: [Element, string][];
+    /** Views that need post-processing */
+    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];
+interface FrameInvokeEntry {
+    /** Method name */
+    name: string;
+    /** Method arguments */
+    args: unknown[];
+    /** 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 */
+    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 {
+    /** Selector name list */
+    selectors: string[];
+    /** Index signature for checking if selector is already registered */
+    [selector: string]: unknown;
+}
+interface ViewLocationObserved {
+    /** Whether observing location */
+    flag: number;
+    /** Keys to observe */
+    keys: string[];
+    /** Whether observing path */
+    observePath: boolean;
+}
+interface ViewResourceEntry {
+    /** The resource entity */
+    entity: unknown;
+    /** Whether to destroy when render() is called */
+    destroyOnRender: boolean;
+}
+interface ViewGlobalEventEntry {
+    /** Handler function */
+    handler: AnyFunc;
+    /** Bound handler wrapper (for removeEventListener) */
+    boundHandler?: AnyFunc;
+    /** DOM element (window/document) */
+    element: EventTarget;
+    /** Event name */
+    eventName: string;
+    /** Modifiers */
+    modifiers: Record<string, boolean>;
+}
 /**
- * Clear all marks for a host object, invalidating all existing checkers.
- * Called when a view re-renders or is destroyed.
- *
- * @param host - Object whose marks should be cleared
+ * 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.
  */
-declare function unmark$1(host: object): void;
-
+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;
+}
 /**
- * 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 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,
+     * 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;
+    /**
+     * 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: Record<string, ViewResourceEntry>;
+    /** Selector event map: eventType -> selector list */
+    eventSelectorMap: Record<string, ViewEventSelectorEntry>;
+    /** Event object map: eventType -> bitmask */
+    eventObjectMap: Record<string, number>;
+    /** Global event list */
+    globalEventList: ViewGlobalEventEntry[];
+    /** Assign method reference */
+    assignMethod?: AnyFunc;
+    /** Whether endUpdate has been called (1 = pending) */
+    endUpdatePending?: number;
+    /** Render method (wrapped) */
+    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 */
+    renderMethod?: AnyFunc;
+    /** endUpdate pending flag */
+    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 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;
+}
+type ExtendThisType<T> = Record<string, unknown> & ThisType<T>;
 /**
- * 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
+ * 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.
  */
-declare function safeguard<T>(data: T, getter?: ((key: string) => void) | null, setter?: ((path: string, value: unknown) => void) | null, isRoot?: boolean): T;
-
+interface FrameInterface extends EventEmitterInterface<FrameInterface> {
+    /**
+     * DOM node ID where Frame resides.
+     */
+    id: string;
+    /**
+     * 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;
+    /**
+     * 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[];
+}
 /**
- * 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');
+ * 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.
  */
-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;
+interface UpdaterInterface {
     /**
-     * Get a cached value by key.
-     * Updates frequency and timestamp for cache sorting.
+     * 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(key: string): T | undefined;
+    get: <T = unknown>(key?: string) => T;
     /**
-     * Iterate all cached values.
+     * 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
      */
-    forEach(callback: (value: T | undefined) => void): void;
+    set: (data: Record<string, unknown>, excludes?: Set<string>) => UpdaterInterface;
     /**
-     * Set or update a cached value.
-     * If key already exists, updates value and increments frequency.
-     * If cache exceeds capacity, triggers eviction.
+     * 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
      */
-    set(key: string, value: T): void;
+    digest: (data?: Record<string, unknown>, excludes?: Set<string>, callback?: () => void) => void;
     /**
-     * Delete a cached entry.
+     * Save a snapshot of current data for altered() detection.
+     * Works with `altered()` method to detect whether data has changed.
      */
-    del(key: string): void;
+    snapshot: () => UpdaterInterface;
     /**
-     * Check if a key exists in cache.
+     * Check if data has changed since last snapshot.
+     * Returns undefined if `snapshot()` has not been called.
      */
-    has(key: string): boolean;
-    /** Get current cache size */
-    get size(): number;
-    /** Clear all entries */
-    clear(): void;
-    /** Evict least-used entries from cache */
-    private evictEntries;
+    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;
 }
-
 /**
- * Multi-cast event emitter class.
- *
- * @example
- * const emitter = new EventEmitter();
- * emitter.on('change', (data) => console.log(data));
- * emitter.fire('change', { key: 'value' });
+ * 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.
  */
-declare class EventEmitter {
-    /** Event listeners: prefixed key -> listener array */
-    private listeners;
+interface PayloadInterface {
     /**
-     * Bind event listener.
+     * Get data from Payload by key.
+     * @param key Data key name
      */
-    on(event: string, handler: AnyFunc): this;
+    get<T = unknown>(key: string): T;
     /**
-     * Unbind event listener.
-     * If handler is provided, removes only that handler.
-     * If no handler, removes all handlers for the event.
+     * 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
      */
-    off(event: string, handler?: AnyFunc): this;
+    set(keyOrData: string | Record<string, unknown> | ServiceMetaEntry, value?: unknown): PayloadInterface;
+    data: Record<string, unknown>;
+    cacheInfo?: ServiceCacheInfo;
+}
+/**
+ * Change event object.
+ */
+interface ChangeEvent {
     /**
-     * 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
+     * Event type.
      */
-    fire(event: string, data?: Record<string, unknown>, remove?: boolean, lastToFirst?: boolean): this;
+    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>>;
 }
-
-/** 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.
+ * 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.
  */
-declare const State: {
+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(data: Record<string, unknown>, excludes?: Set<string>): typeof State;
-    digest(data?: Record<string, unknown>, excludes?: Set<string>): void;
-    diff(): Readonly<Record<string, number>>;
+    /**
+     * 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;
     };
-    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;
-
+    /**
+     * 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 */
+    url: string;
+    /** Request params */
+    params?: Record<string, unknown>;
+    /** HTTP method */
+    method?: "GET" | "POST" | "PUT" | "DELETE" | string;
+    /** Cache: true for default, number for TTL */
+    cache?: boolean | number;
+    /** POST data */
+    data?: unknown;
+}
+interface PayloadEntry {
+    /** Payload data */
+    data: Record<string, unknown>;
+}
+interface ServiceEntry {
+    /** Service ID */
+    id: string;
+    /** Service URL */
+    url: string;
+    /** Cache time in ms, 0 = no cache */
+    cacheTime: number;
+    /** Payload instance */
+    payload?: PayloadEntry;
+    /** Whether loading */
+    loading?: boolean;
+    /** Error info */
+    error?: Error;
+}
+/** Pending cache entry for deduplication (internal to Service) */
+interface PendingCacheEntry extends Array<unknown> {
+    /** Reference to the pending Payload entity */
+    entity?: unknown;
+}
 /**
- * Base View class.
- * Views are created via View.extend() and mounted by Frame.
- *
+ * Endpoint metadata configuration for registering an API endpoint with Service.
+ * Each meta describes endpoint's URL, cache strategy, before/after interceptors, etc.
  */
-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;
+interface ServiceMetaEntry {
+    /**
+     * Endpoint name,
+     * Unique name for endpoint metadata, must be unique within same Service.
+     */
+    name: string;
+    /** Request URL, required. */
+    url: string;
+    /**
+     * 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,
+     * 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 Payload entity */
+interface ServiceCacheInfo {
+    /** Endpoint name */
+    name: string;
+    /** After-fetch hook */
+    after?: AnyFunc | undefined;
+    /** Clean keys */
+    cleans?: string | undefined;
+    /** Cache key */
+    key: string;
+    /** 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;
     /**
-     * Initialize view (called by Frame when mounting).
+     * 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
      */
-    init(): void;
+    toUrl(path: string, params?: Record<string, unknown>, keepEmpty?: Record<string, number>): string;
     /**
-     * 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
-     *
+     * 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
      */
-    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;
+    parseUrl(url: string): ParsedUri;
     /**
-     * Notify view that HTML update is about to begin.
-     * Unmounts child frames in the update zone.
+     * Merge source object properties into target object.
+     * @param target Target object
+     * @param sources One or more source objects
      */
-    beginUpdate(id?: string): void;
+    mix<T extends object>(target: T, ...sources: Partial<T>[]): T;
     /**
-     * Notify view that HTML update has ended.
-     * Mounts child frames in the update zone and runs deferred invokes.
+     * Check if object has specified own property (safe hasOwnProperty).
+     * @param owner Object to check, supports undefined/null
+     * @param prop Property key name
      */
-    endUpdate(id?: string, inner?: boolean): void;
+    has<T extends object>(owner: T | undefined | null, prop: PropertyKey): boolean;
     /**
-     * Wrap an async callback to check view signature before executing.
-     * If the view has been re-rendered or destroyed, the callback is skipped.
+     * Get enumerable property keys of object as array.
+     * @param src Source object
      */
-    wrapAsync<Fn extends AnyFunc>(fn: Fn, context?: unknown): (...args: Parameters<Fn>) => ReturnType<Fn> | undefined;
+    keys<T extends object>(src: T): string[];
     /**
-     * Observe location parameters or path changes.
-     * When observed keys change, render() is called automatically.
+     * 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
      */
-    observeLocation(params: string | string[] | Record<string, unknown>, observePath?: boolean): void;
+    inside(node: HTMLElement | string, container: HTMLElement | string): boolean;
     /**
-     * Observe State data keys for changes.
-     * When observed keys change via State.digest(), render() is called.
+     * Shorthand for document.getElementById.
+     * Returns directly if Element is passed.
+     * @param id Node ID or Element object
      */
-    observeState(observedKeys: string | string[]): void;
+    node(id: string | Element | null): Element | null;
     /**
-     * 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.
+     * Ensure DOM element has an ID, auto-generates one if missing.
+     * Returns element's ID.
+     * @param node DOM element object
      */
-    capture(key: string, resource?: unknown, destroyOnRender?: boolean): unknown;
+    nodeId(node: HTMLElement): string;
     /**
-     * Release a captured resource.
-     * If destroy=true, calls the resource's destroy() method.
+     * Load modules using configured module loader.
+     * @param names Module names, supports string or string array
+     * @param callback Callback after modules are loaded
      */
-    release(key: string, destroy?: boolean): unknown;
+    use(names: string | string[], callback?: (...modules: unknown[]) => void): void;
     /**
-     * Set up a leave confirmation for route changes and page unload.
+     * 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
      */
-    leaveTip(message: string, condition: () => boolean): void;
-    /** Collected ctors from mixins */
-    static ctors?: AnyFunc[];
+    guard<T extends object>(o: T): T;
     /**
-     * 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.
+     * 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)
      */
-    static extend(props?: ThisType<ViewInstance> & Record<string, unknown>, statics?: Record<string, unknown>): typeof View;
+    applyStyle(styleIdOrPairs: string | string[], cssText?: string): () => void;
     /**
-     * Merge mixins into View prototype.
+     * 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.
      */
-    static merge(...mixins: Record<string, unknown>[]): typeof View;
+    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.
+     * 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 root view path to load when URL doesn't match any route.
+     */
+    defaultView?: string;
+    /**
+     * Default path when no hash present,
+     * Path used when URL hash is empty, defaults to "/".
+     */
+    defaultPath?: string;
+    /**
+     * 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.
+     * 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.
+     * Array of extension view paths to load during app startup.
+     * These extension views are loaded before app initialization.
+     */
+    extensions?: string[];
+    /** Init module to load */
+    initModule?: string;
+    /** Rewrite function for routes */
+    rewrite?: (path: string, params: Record<string, string>, routes: Record<string, string>) => string;
+    /**
+     * Unmatched view (404).
+     * View path to use when no matching view is found in routes, e.g., 404 page.
+     */
+    unmatchedView?: string;
+    /**
+     * Module require function
+     */
+    require?: (names: string[], params?: Record<string, unknown>) => Promise<unknown> | undefined;
+    /** Skip view rendered check */
+    skipViewRendered?: boolean;
+    /** Dynamic config access, custom config items */
+    [key: string]: unknown;
+}
+interface RouteViewConfig {
+    /** View path */
+    view: string;
+    /** Additional properties merged into location */
+    [key: string]: unknown;
+}
+/** Element with VDOM diff cached compare key */
+interface VdomElement extends Element {
+    /** Whether compare key is cached */
+    compareKeyCached?: number | undefined;
+    /** Cached compare key */
+    cachedCompareKey?: string | undefined;
+    /** Whether auto-generated ID */
+    autoId?: number;
+}
+/** Element with frame binding */
+interface FrameBoundElement extends HTMLElement {
+    /** Frame instance bound to this element */
+    frame?: FrameInterface;
+    /** Whether frame is bound (1 = bound) */
+    frameBound?: number;
+    /** View rendered flag */
+    viewRendered?: number;
+    /** Range frame ID */
+    rangeFrameId?: string;
+    /** 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;
 }
 
 /**
- * Frame (View Frame) class for view lifecycle management.
- * Each frame owns a view and manages child frames.
+ * Lark framework utility functions.
+ */
+
+/** Check if value is a plain object (not null, not array, typeof object) */
+declare function isPlainObject(value: unknown): value is Record<string, unknown>;
+/** Check if value is primitive or function (not a complex object) */
+declare function isPrimitiveOrFunc(value: unknown): boolean;
+/** Check if value is primitive (not object, not function) */
+declare function isPrimitive(value: unknown): boolean;
+declare function generateId(prefix?: string): string;
+/** Sync local counter with global counter */
+declare function syncCounter(val: number): void;
+declare function noop(): void;
+/** Safe hasOwnProperty check */
+declare function has<T extends object>(owner: T | undefined | null, prop: PropertyKey): boolean;
+/** Get object keys (own enumerable) */
+declare function keys<T extends object>(obj: T): string[];
+/** Assign properties from sources to target (like Object.assign but safer) */
+declare function assign<T extends object>(target: T, ...sources: Partial<T>[]): T;
+/**
+ * Execute functions in try-catch, ignoring errors.
+ * Returns the result of the last successfully executed function.
+ */
+declare function funcWithTry(fns: AnyFunc | AnyFunc[], args: unknown[], context: unknown, configError?: (e: unknown) => void): unknown;
+/**
+ * Set newData into oldData, tracking changed keys.
+ * Returns whether any value changed.
+ */
+declare function setData(newData: Record<string, unknown>, oldData: Record<string, unknown>, changedKeys: Record<string, number>, excludes: Set<string>): boolean;
+/**
+ * Translate data references: if a value starts with SPLITTER, replace it
+ * with the corresponding value from the data object.
+ */
+declare function translateData(data: object, value: unknown): unknown;
+/** Get element by ID, or return the element itself if already an element */
+declare function getById(id: string | Element | null): Element | null;
+/** Get attribute from element safely */
+declare function getAttribute(element: Element, attr: string): string;
+/** Ensure element has an ID, generating one if missing. Returns the ID. */
+declare function ensureElementId(element: HTMLElement): string;
+/**
+ * Check if node A is inside node B (or is the same node).
+ * Uses compareDocumentPosition for efficiency.
+ */
+declare function nodeInside(a: string | HTMLElement, b: string | HTMLElement): boolean;
+/**
+ * Parse URI string into path and params object.
+ * e.g. "/xxx/?a=b&c=d" => { path: "/xxx/", params: { a: "b", c: "d" } }
+ */
+declare function parseUri(uri: string): ParsedUri;
+/**
+ * Convert path and params to URI string.
+ * e.g. toUri("/xxx/", { a: "b", c: "d" }) => "/xxx/?a=b&c=d"
+ */
+declare function toUri(path: string, params: Record<string, unknown>, keepEmptyObject?: Record<string, number>): string;
+/**
+ * Convert array to map/hash object.
+ * For simple arrays, counts occurrences.
+ * For object arrays, uses specified key as map key.
+ */
+declare function toMap<T>(list: T[] | null | undefined, key?: keyof T): Record<string, T | number>;
+/** Get current timestamp */
+declare function now(): number;
+/** Constructable function type */
+type Constructable = new (...args: never[]) => unknown;
+/**
+ * Implement classical inheritance with prototype chain.
+ * 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>(make: Constructable, base: Constructable, props: Proto, statics: Statics): void;
+
+/** Internal splitter character (invisible, used as namespace separator) */
+declare const SPLITTER = "\u001E";
+declare const ROUTER_EVENTS: {
+    CHANGE: string;
+    CHANGED: string;
+    PAGE_UNLOAD: string;
+};
+/** Attribute name: v-lark */
+declare const LARK_VIEW = "v-lark";
+/** View event method regex: e.g. "app\x1eclickHandler(click)" or "clickHandler()"
+ * Group 1: optional frame ID (before SPLITTER)
+ * Group 2: handler name
+ * Group 3: params string
+ */
+declare const EVENT_METHOD_REGEXP: RegExp;
+/** View event method name regex: e.g. "name<click,mousedown>" or "$selector<click>" */
+declare const VIEW_EVENT_METHOD_REGEXP: RegExp;
+/** Tag name regexp for I_GetNode */
+declare const TAG_NAME_REGEXP: RegExp;
+/** Async task break time (ms) */
+declare const CALL_BREAK_TIME = 48;
+/** Increment global counter and return new value */
+declare function nextCounter(): number;
+
+/**
+ * Dynamically inject CSS styles into the document head.
+ * Returns a cleanup function to remove the injected styles.
+ *
+ * @param styleIdOrPairs - Style ID string or array of [id, content] pairs
+ * @param css - CSS content string (only used when first arg is string)
+ * @returns Cleanup function to remove the styles
+ */
+declare function applyStyle(styleIdOrPairs: string | string[], css?: string): () => void;
+
+/**
+ * Mark/Unmark: signature-based lifecycle tracking for async callbacks.
+ *
+ * mark() returns a validity checker function. If the host is "unmarked"
+ * (e.g. view re-rendered), the checker returns false, preventing stale callbacks.
+ */
+/**
+ * Create a mark for tracking async callback validity.
+ * Returns a function that checks if the mark is still valid.
+ *
+ * @param host - Object to store mark state on (typically a view)
+ * @param key - Key to track (typically "render" or specific async operation)
+ * @returns Checker function that returns true if mark is still valid
+ */
+declare function mark$1(host: object, key: string): () => boolean;
+/**
+ * Clear all marks for a host object, invalidating all existing checkers.
+ * Called when a view re-renders or is destroyed.
+ *
+ * @param host - Object whose marks should be cleared
+ */
+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
  */
-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 (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>): 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;
-}
 /**
- * Register a View class for a given view path.
- * Called after module loading completes.
+ * 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 registerViewClass(viewPath: string, ViewClass: typeof View): 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;
+/**
+ * Observable in-memory data object.
+ * Provides get/set/digest/diff/clean methods for cross-view data sharing.
+ */
+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.
@@ -892,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.
  */
@@ -923,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 */
@@ -988,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): {
-            make: 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
  *
@@ -1252,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>;
@@ -1304,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;
@@ -1327,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;
     /**
      *
@@ -1339,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: {
@@ -1384,7 +2081,7 @@ 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>, {
     make: AnyFunc;
 }];
@@ -1464,9 +2161,9 @@ declare function installFrameVisualizerBridge(): void;
  *   extractGlobalVars()   (AST-based global var analysis via @babel/parser)
  *
  * - All template operators: = (escape), ! (raw), @ (ref lookup), : (binding)
- * - @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
@@ -1476,25 +2173,17 @@ declare function installFrameVisualizerBridge(): void;
  *   {{: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.
@@ -1503,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
@@ -1528,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, type SerializedFrameNode, type SerializedFrameTree, type SerializedViewInfo, Service, type ServiceCacheInfo, type ServiceConstructor, type ServiceEntry, type ServiceMetaEntry, type ServiceOptions, State, type StoreConfig, type StoreMethods, TAG_NAME_REGEXP, 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, installFrameVisualizerBridge, isArray, 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 };
+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 };