@lark.js/mvc 0.0.3 → 0.0.5

package/dist/index.d.cts

@@ -1,6 +1,469 @@
+/**
+ * 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[]>;
+    /** Number of `fire()` calls currently on the stack (re-entrancy depth). */
+    private firingDepth;
+    /** Keys whose listener list needs compaction after firing settles. */
+    private pendingCompaction;
+    /**
+     * 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. Safe for re-entrant `off()` calls
+     * during dispatch: removed handlers are replaced with noop and compacted
+     * after the outermost fire returns.
+     *
+     * @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;
+}
+
+/**
+ * Base View class.
+ * Views are created via View.extend() and mounted by Frame.
+ */
+declare class View implements ViewInterface {
+    /** View ID (same as owner frame ID) */
+    id: string;
+    /** Owner frame */
+    owner: FrameInterface | number;
+    /** Updater instance */
+    updater: UpdaterInterface;
+    /** Signature: > 0 means active, incremented on render, 0 = destroyed */
+    signature: number;
+    /** Whether rendered at least once */
+    rendered?: boolean;
+    /** Whether view has template */
+    template?: ViewTemplate;
+    /** Location observation config */
+    locationObserved: ViewLocationObserved;
+    /** Observed state keys */
+    observedStateKeys?: string[];
+    /** Resource map */
+    resources: Record<string, ViewResourceEntry>;
+    /** Assign method reference */
+    assignMethod?: AnyFunc;
+    /** Whether endUpdate pending */
+    endUpdatePending?: number;
+    /** Internal event storage */
+    private _events;
+    /** Prototype-stored event maps shape (set by View.prepare). */
+    private get protoEventState();
+    /**
+     * 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;
+    /** Get the owning frame, asserting it has been bound. */
+    private get ownerFrame();
+    /**
+     * 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;
+}
+/**
+ * Type-safe wrapper around `View.extend()`.
+ *
+ * `View.extend({...})` accepts any object literal, and inside its methods
+ * `this` is typed only as the base `ViewInterface` — so any custom state
+ * field or helper method requires a `(this as MyView).foo` strong-cast at
+ * every call site.
+ *
+ * `defineView()` threads the literal's own shape back into `this` via
+ * `ThisType<P & ViewInterface>`, so `this.foo` is typed automatically:
+ *
+ * ```ts
+ * const HomeView = defineView({
+ *   $title: "Home",
+ *   init() {
+ *     this.updater.set({ title: this.$title }); // both typed
+ *   },
+ *   greet() {
+ *     return `hello ${this.$title}`;
+ *   },
+ * });
+ * ```
+ *
+ * Runtime semantics are identical to `View.extend(props, statics)` — this is
+ * a zero-cost type-only wrapper.
+ */
+declare function defineView<P extends Record<string, unknown>>(props: P & ThisType<P & ViewInterface>, statics?: Record<string, unknown>): typeof View;
+
+/**
+ * Register a View class for a given view path.
+ * Called after module loading completes (or up front during boot).
+ */
+declare function registerViewClass(viewPath: string, ViewClass: typeof View): void;
+/**
+ * Invalidate a View class from the registry.
+ * Used by HMR to force re-loading of a view module.
+ */
+declare function invalidateViewClass(viewPath: string): void;
+
+/**
+ * Frame (View Frame) class for view lifecycle management.
+ * Each frame owns a view and manages child frames.
+ *
+ */
+declare class Frame extends EventEmitter implements FrameInterface {
+    /** Frame ID (same as owner DOM element ID) */
+    readonly id: string;
+    /** Parent Frame ID */
+    private _parentId;
+    get parentId(): string | undefined;
+    /** Children map: id -> id */
+    childrenMap: Record<string, string>;
+    /** Children count */
+    childrenCount: number;
+    /** Ready count (children that have fired 'created') */
+    readyCount: number;
+    /** Set of child frame IDs that have fired 'created' */
+    readyMap: Set<string>;
+    /** 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, unknown>, 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;
+    /**
+     * Type-safe variant of `invoke`.
+     *
+     * `invoke()` accepts any string and any args, which silently hides
+     * mismatched call sites when a method gets renamed. `invokeTyped` carries
+     * the view's method signature through TypeScript so the compiler catches
+     * those mistakes:
+     *
+     * ```ts
+     * type Home = View & { loadData(id: string): Promise<void> };
+     * frame.invokeTyped<Home, "loadData">("loadData", ["user-1"]);
+     * ```
+     *
+     * Behavior is identical to `invoke` at runtime — same defer / direct-call
+     * paths — so it's a drop-in safer overload.
+     */
+    invokeTyped<V extends Record<string, unknown>, K extends keyof V & string>(name: K, args: V[K] extends (...a: infer A) => unknown ? A : never[]): V[K] extends (...a: never[]) => infer R ? R | undefined : unknown;
+    /** Get frame by ID */
+    static get(id: string): Frame | undefined;
+    /** Get all frames */
+    static getAll(): Map<string, Frame>;
+    /**
+     * Returns the existing root frame, or `undefined` if none has been created.
+     * Pure getter — never creates a Frame, never touches the DOM.
+     *
+     * Use `Frame.createRoot(id)` to create the root explicitly during framework
+     * boot. For Micro-Frontend hosts that own multiple independent containers,
+     * use `new Frame(containerId)` directly so each MF mount has its own root.
+     */
+    static getRoot(): Frame | undefined;
+    /**
+     * Create (or return) the singleton root frame for this app.
+     *
+     * Idempotent: subsequent calls always return the original root regardless
+     * of `rootId` — so passing a different id later is silently ignored.
+     * `Framework.boot()` is the canonical caller; user code rarely needs this.
+     */
+    static createRoot(rootId?: string): Frame;
+    /**
+     * @deprecated Use `Frame.getRoot()` for read-only access or
+     * `Frame.createRoot(id)` to create the root explicitly. The single-method
+     * `root()` blurred the distinction and was a common source of bugs in
+     * Micro-Frontend hosts.
+     *
+     * Kept for backward compatibility — behavior unchanged.
+     */
+    static root(rootId?: string): Frame;
+    /** Bind event listener (static) */
+    static on(event: string, handler: AnyFunc): typeof Frame;
+    /** Unbind event listener (static) */
+    static off(event: string, handler?: AnyFunc): typeof Frame;
+    /** Fire event (static) */
+    static fire(event: string, data?: Record<string, unknown>): void;
+}
+
+/**
+ * Cache class with LFU-style eviction.
+ * Keys are prefixed with SPLITTER for namespace isolation.
+ *
+ * @example
+ * const cache = new Cache({ maxSize: 20, bufferSize: 5 });
+ * cache.set('user', { name: 'Alice' });
+ * const user = cache.get('user');
+ * cache.has('user'); // true
+ * cache.del('user');
+ */
+declare class Cache<T = unknown> implements CacheInterface<T> {
+    /** Cache entries array */
+    private entries;
+    /** Fast lookup: prefixed key -> entry */
+    private lookup;
+    /** Buffer size for eviction */
+    private readonly bufferSize;
+    /** Maximum cache size */
+    private readonly maxSize;
+    /** Total capacity (maxSize + bufferSize) */
+    private readonly capacity;
+    /** Callback when entry is removed */
+    private readonly onRemove?;
+    /** Sort comparator */
+    private readonly comparator;
+    constructor(options?: CacheOptions<T>);
+    /** Prefix a key with SPLITTER for namespace isolation */
+    private prefixKey;
+    /**
+     * Get a cached value by key.
+     * Updates frequency and timestamp for cache sorting.
+     */
+    get(key: string): T | undefined;
+    /**
+     * Iterate all cached values.
+     */
+    forEach(callback: (value: T | undefined) => void): void;
+    /**
+     * Set or update a cached value.
+     * If key already exists, updates value and increments frequency.
+     * If cache exceeds capacity, triggers eviction.
+     */
+    set(key: string, value: T): void;
+    /**
+     * Delete a cached entry. Removes it immediately from both the lookup map
+     * and the entries array so the GC can reclaim the value without waiting
+     * for the next eviction sweep.
+     */
+    del(key: string): void;
+    /**
+     * Check if a key exists in cache.
+     */
+    has(key: string): boolean;
+    /** Get current cache size */
+    get size(): number;
+    /** Clear all entries */
+    clear(): void;
+    /**
+     * Evict the `bufferSize` worst entries from the cache.
+     *
+     * Uses single-pass partial selection (O(n·k)) instead of sorting the entire
+     * `entries` array (O(n log n)). For the typical `bufferSize = 5` this is
+     * effectively a linear scan with at most 5 in-bucket comparisons per
+     * iteration — and it avoids mutating the rest of `entries`.
+     */
+    private evictEntries;
+}
+
 /**
  * Lark framework type definitions.
  * All shared types are defined here to eliminate type cheats across modules.
+ *
+ * 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: simple cross-view observable singleton (recommended for simple cases)
+ * - Store: complex Proxy-based reactive state with observe/handlers/multi-instance
+ *   (recommended for complex cases)
+ * - Service: API request management with caching, queuing, and deduplication
+ * - Frame: view frame managing view mount/unmount lifecycle
+ * - Updater: view data binding and VDOM diff (in-memory real DOM diff) renderer
+ *
+ * Designed for single-page application (SPA) development.
  */
 /** Generic function type for event handlers and callbacks.
  *  Uses any[] to accept callbacks with specific parameter types
@@ -29,81 +492,190 @@ interface CacheOptions<T> {
     /** Comparator for sorting entries */
     sortComparator?: (a: CacheEntry<T>, b: CacheEntry<T>) => number;
 }
+/**
+ * Cache interface providing LFU (Least Frequently Used) cache management.
+ * Cache keys use a special prefix internally for namespace isolation.
+ */
+interface CacheInterface<T = unknown> {
+    /**
+     * Set a cache resource. If the key exists, updates the value and increments frequency.
+     * Triggers LFU eviction when cache entries exceed capacity (maxSize + bufferSize).
+     * @param key Unique identifier for the cached resource
+     * @param resource The resource to cache
+     */
+    set(key: string, resource: T): void;
+    /**
+     * Get a cached resource. Access increments frequency count and timestamp for LFU ranking.
+     * Returns undefined if the key does not exist.
+     * @param key Cache resource key
+     */
+    get(key: string): T | undefined;
+    /**
+     * Remove a resource from cache by key. Triggers onRemove callback on deletion.
+     * @param key Cache resource key to remove
+     */
+    del(key: string): void;
+    /**
+     * Check if cache contains a resource for the given key.
+     * @param key Cache resource key
+     */
+    has(key: string): boolean;
+    /**
+     * Iterate over all cached resource values.
+     * @param callback Iteration callback receiving the cached value (may be undefined)
+     */
+    forEach(callback: (value: T | undefined) => void): void;
+    /**
+     * Number of cache entries.
+     */
+    readonly size: number;
+    /**
+     * Clear all cache entries. Triggers onRemove callback for each deleted entry.
+     */
+    clear(): void;
+}
 interface EventListenerEntry {
     /** Handler function */
     handler: AnyFunc;
     /** Whether currently executing (1 = executing, '' = done) */
     executing: number | string;
 }
+/**
+ * Parsed URL result containing path and parameters.
+ * Returned by `Router.parse()`, includes the path string and parsed key-value parameter pairs.
+ */
 interface ParsedUri {
-    /** Path portion (before ? or #) */
+    /** Path portion (before ? or #), excluding query parameters */
     path: string;
-    /** Key-value params */
+    /** Key-value params parsed from the URL */
     params: Record<string, string>;
 }
+/**
+ * Current URL parsing result interface.
+ * Returned by `Router.parse()`, includes both query (after ?) and hash (after #) sections.
+ */
 interface Location {
-    /** Full href */
+    /** Full href, original href string */
     href: string;
-    /** Query string (before #) */
+    /** Query string (before #), raw query string (after ?, before #) */
     srcQuery: string;
-    /** Hash string (after #) */
+    /** Hash string (after #), raw hash string (after #) */
     srcHash: string;
-    /** Parsed query object */
+    /** Parsed query object, path and params parsed from srcQuery */
     query: ParsedUri;
-    /** Parsed hash object */
+    /** Parsed hash object, path and params parsed from srcHash */
     hash: ParsedUri;
-    /** Merged params from query and hash */
+    /**
+     * Merged params from query and hash,
+     * hash values take precedence when keys conflict.
+     */
     params: Record<string, string>;
-    /** Resolved view path */
+    /**
+     * Resolved view path for the current URL.
+     * May be undefined before framework boot.
+     */
     view?: string;
-    /** Resolved path */
+    /**
+     * Resolved path computed from hash path and query path based on routing rules.
+     * May be undefined before framework boot.
+     */
     path?: string;
-    /** Get param by key with optional default */
+    /**
+     * Get param by key with optional default value.
+     * Returns default value or empty string if key does not exist.
+     * @param key Parameter key name
+     * @param defaultValue Default value when key is missing, defaults to empty string
+     */
     get: (key: string, defaultValue?: string) => string;
 }
+/**
+ * URL parameter change representing a parameter value transition from old to new.
+ * Used in `Router.diff()` return value to describe parameter changes.
+ */
 interface ParamDiff {
+    /** Value before the change */
     from: string;
+    /** Value after the change */
     to: string;
 }
+/**
+ * URL route change object interface describing changes between two routing states.
+ * Returned by `Router.diff()`, includes changes in path, view, and other parameters.
+ */
 interface LocationDiff {
-    /** Changed params (key -> {from, to}) */
+    /**
+     * Changed params (key -> {from, to}),
+     * diff for all changed parameters
+     */
     params: Record<string, ParamDiff>;
-    /** Whether path changed */
+    /** Path diff when path has changed */
     path?: ParamDiff;
-    /** Whether view changed */
+    /** View diff when rendered view has changed */
     view?: ParamDiff;
-    /** Whether this is a first forced change */
+    /**
+     * Whether this is a first forced change during app initialization.
+     */
     force: boolean;
-    /** Whether anything changed */
+    /** Whether any content has changed */
     changed: boolean;
 }
+/**
+ * Route pre-change event interface (change phase).
+ * Provides two-phase confirmation: triggers change (can be rejected), then changed.
+ * Can prevent, reject, or accept route changes through this event object.
+ */
+interface RouteChangeEvent extends ChangeEvent {
+    /**
+     * Reject the URL change, revert to previous URL.
+     */
+    reject: () => void;
+    /**
+     * Accept the URL change, continue navigation.
+     */
+    resolve: () => void;
+    /**
+     * Prevent the URL change, pause subsequent route processing.
+     */
+    prevent: () => void;
+}
+/**
+ * Route post-change event interface (changed phase).
+ * Carries route diff information. Triggered after route change is confirmed and URL is updated.
+ */
+type RouteChangedEvent = LocationDiff & ChangeEvent;
 interface VDomRef {
     /** ID update list: [element, newId][] */
     idUpdates: [Element, string][];
     /** Views that need post-processing */
-    views: ViewInstance[];
+    views: ViewInterface[];
     /** DOM operation list: [opCode, parent, newChild?, oldChild?][] */
     domOps: VDomOp[];
     /** Whether anything changed */
     hasChanged: number;
 }
-type VDomOp = [1, Element, Element] | [2, Element, Element] | [4, Element, Element, Element] | [8, Element, Element, Element];
-type FrameChildrenMap = Record<string, string>;
-type FrameReadyMap = Record<string, number>;
+/**
+ * Encoded VDOM mutation. The op code matches `Node.appendChild` family at the
+ * DOM level — parents are always Elements (you can't appendChild onto text)
+ * but the moving / replaced child can be any ChildNode (Element / Text /
+ * Comment), so the child slots are typed as ChildNode.
+ */
+type VDomOp = [1, Element, ChildNode] | [2, Element, ChildNode] | [4, Element, ChildNode, ChildNode] | [8, Element, ChildNode, ChildNode];
 interface FrameInvokeEntry {
     /** Method name */
     name: string;
     /** Method arguments */
     args: unknown[];
-    /** Internal key for dedup */
+    /** Internal key */
     key: string;
     /** Whether removed (args match) */
     removed?: boolean;
 }
 /** Mixin event handler with internal merge marker and handler list */
 interface MixinEventHandler extends AnyFunc {
-    /** Merged handler list */ a?: AnyFunc[];
-    /** Mixin marker: 1 = this is a mixin function */ b?: number;
+    /** Merged handler list */
+    handlerList?: AnyFunc[];
+    /** Mixin marker: 1 = this is a mixin function */
+    marker?: number;
 }
 /** View event selector map entry: handler name list with selector presence tracking */
 interface ViewEventSelectorEntry {
@@ -112,8 +684,12 @@ interface ViewEventSelectorEntry {
     /** Index signature for checking if selector is already registered */
     [selector: string]: unknown;
 }
-/** View class internal markers (SPLITTER key) */
-type ViewClassInternal = Record<string, AnyFunc[]>;
+/**
+ * Compiled template function signature.
+ * `data`/`viewId`/`refData` are required; subsequent encoder args are
+ * injected by the Updater (encodeHTML/encodeSafe/encodeURIExtra/refFn/encodeQ).
+ */
+type ViewTemplate = (data: unknown, viewId: string, refData: unknown, ...encoders: unknown[]) => string;
 interface ViewLocationObserved {
     /** Whether observing location */
     flag: number;
@@ -128,8 +704,6 @@ interface ViewResourceEntry {
     /** Whether to destroy when render() is called */
     destroyOnRender: boolean;
 }
-type ViewResourceMap = Record<string, ViewResourceEntry>;
-type ViewEventSelectorMap = Record<string, ViewEventSelectorEntry>;
 interface ViewGlobalEventEntry {
     /** Handler function */
     handler: AnyFunc;
@@ -142,30 +716,160 @@ interface ViewGlobalEventEntry {
     /** Modifiers */
     modifiers: Record<string, boolean>;
 }
-type ViewEventObjectMap = Record<string, number>;
-interface ViewInstance {
-    /** View ID (same as owner frame ID) */
+/**
+ * View configuration for listening to URL changes.
+ * Used as object parameter for `observeLocation()` method.
+ */
+interface ViewObserveLocation {
+    /**
+     * Whether to listen for path changes.
+     */
+    observePath?: boolean;
+    /**
+     * Parameter keys to observe, supports comma-separated string or string array.
+     */
+    params?: string | string[];
+}
+/**
+ * Router interface providing URL parsing, navigation, diff, and event listening capabilities.
+ * Supports two-phase route confirmation mechanism: change (can reject) → changed.
+ * Hash-based implementation using #! as default hash prefix.
+ */
+interface RouterInterface extends EventEmitterInterface<RouterInterface> {
+    /**
+     * Parse href into Location object.
+     * Parses query and hash sections of href, returns structured routing information.
+     * Defaults to parsing current page `location.href`.
+     * @param href URL to parse, uses `location.href` if not specified
+     */
+    parse(href?: string): Location;
+    /**
+     * Compute diff between current and previous location.
+     * Returns undefined if no routing changes have occurred yet.
+     */
+    diff(): LocationDiff | undefined;
+    /**
+     * Navigate to new URL.
+     * Supports two calling modes:
+     * - `Router.to("/list", { page: 2 })` specify path and params
+     * - `Router.to({ page: 2 })` update params only, keep current path
+     * @param pathOrParams Path string or params object
+     * @param params Query params object (only used when first arg is path string)
+     * @param replace Whether to replace current history entry instead of adding new one
+     * @param silent Whether to silently update without triggering change event
+     */
+    to(pathOrParams: string | Record<string, unknown>, params?: Record<string, unknown>, replace?: boolean, silent?: boolean): void;
+    /** Join path segments */
+    join(...paths: string[]): string;
+    /**
+     * Register an async-friendly navigation guard.
+     *
+     * Each guard is invoked with the parsed `(to, from)` Locations. Guards
+     * may return a Promise; the router awaits all guards in registration
+     * order. If any guard:
+     *
+     * - returns / resolves to `false`,
+     * - throws or rejects,
+     *
+     * the navigation is aborted and the URL is reverted. Returning `true`,
+     * `undefined`, or any non-false value permits the navigation.
+     *
+     * Returns an unsubscribe function so the guard can be torn down (e.g.
+     * inside a view's `destroy` handler).
+     */
+    beforeEach(guard: (to: Location, from: Location) => boolean | void | Promise<boolean | void>): () => void;
+    /** 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;
+}
+/**
+ * Service event interface, triggered when request starts or ends.
+ * Includes begin/done/fail/end event types.
+ */
+interface ServiceEvent extends ChangeEvent {
+    /**
+     * Data payload object carrying this request's data.
+     */
+    readonly payload: PayloadInterface;
+    /**
+     * Error object, present if request throws an error, otherwise null.
+     */
+    readonly error: object | string | null;
+}
+/**
+ * View event interface carrying the ID of the node that triggered the event.
+ * Carried in DOM events bound via @event attribute.
+ */
+interface ViewEvent extends ChangeEvent {
+    /**
+     * DOM node ID that triggered the event.
+     */
+    readonly id: string;
+}
+/**
+ * Frame static event interface carrying associated Frame instance.
+ * Carried in Frame's add/remove static events.
+ */
+interface FrameStaticEvent extends ChangeEvent {
+    /**
+     * Associated Frame instance object.
+     */
+    readonly frame: FrameInterface;
+}
+interface ViewInterface extends EventEmitterInterface<ViewInterface> {
+    /**
+     * View ID (same as owner frame ID),
+     * DOM node ID where current view resides.
+     */
     id: string;
-    /** Owner frame */
-    owner: FrameLike | number;
-    /** Updater instance */
-    updater: UpdaterLike;
-    /** Signature: > 0 means active, incremented on render, 0 = destroyed */
+    /**
+     * Owner frame,
+     * Frame instance holding current view.
+     * May be numeric placeholder 0 before view initialization completes.
+     * TODO: Migrate numeric placeholder 0 to undefined or null
+     */
+    owner: FrameInterface | number;
+    /**
+     * Updater instance managing view data binding and VDOM rendering.
+     */
+    updater: UpdaterInterface;
+    /**
+     * Signature: > 0 means active, incremented on render, 0 = destroyed */
     signature: number;
     /** Whether rendered at least once */
     rendered?: boolean;
-    /** Whether view has template */
-    template?: AnyFunc | string;
+    /**
+     * View template function. Receives data + viewId + refData and a set of
+     * encoder helpers wired in by the Updater, and returns the rendered HTML.
+     */
+    template?: ViewTemplate;
+    /**
+     * Mixin object array for extending view functionality.
+     * Framework merges properties and methods from mixins into view prototype.
+     * Event method conflicts are automatically merged into sequential calls.
+     */
+    mixins?: Record<string, unknown>[];
     /** Location observation config */
     locationObserved: ViewLocationObserved;
     /** Observed state keys */
     observedStateKeys?: string[];
     /** Resource map */
-    resources: ViewResourceMap;
+    resources: Record<string, ViewResourceEntry>;
     /** Selector event map: eventType -> selector list */
-    eventSelectorMap: ViewEventSelectorMap;
+    eventSelectorMap: Record<string, ViewEventSelectorEntry>;
     /** Event object map: eventType -> bitmask */
-    eventObjectMap: ViewEventObjectMap;
+    eventObjectMap: Record<string, number>;
     /** Global event list */
     globalEventList: ViewGlobalEventEntry[];
     /** Assign method reference */
@@ -173,53 +877,371 @@ interface ViewInstance {
     /** Whether endUpdate has been called (1 = pending) */
     endUpdatePending?: number;
     /** Render method (wrapped) */
-    render: AnyFunc;
-    /** init method */
-    init: AnyFunc;
+    render(): void;
+    /**
+     * Init method called after view is mounted.
+     * Used for initialization logic.
+     * Framework passes two arguments during actual invocation:
+     * - initParams: initialization parameter object
+     * - options: contains `node: Element` and `deep: boolean`
+     */
+    init(): void;
     /** Wrapped render method */
-    $b?: AnyFunc;
+    renderMethod?: AnyFunc;
     /** endUpdate pending flag */
-    $e?: number;
-    on: (event: string, handler: AnyFunc) => ViewInstance;
-    off: (event: string, handler?: AnyFunc) => ViewInstance;
-    fire: (event: string, data?: Record<string, unknown>, remove?: boolean, lastToFirst?: boolean) => ViewInstance;
+    endUpdatePendingFlag?: number;
+    /**
+     * Notify view that HTML update is about to begin for a specific region.
+     * Framework unmounts child Frames in that region to prevent VDOM diff from operating on unmounted nodes.
+     * @param id Region node ID to update, defaults to current view
+     */
     beginUpdate: (id?: string) => void;
+    /**
+     * Notify view that HTML update has completed for a specific region.
+     * Framework mounts child Frames in that region and executes deferred invoke queue.
+     * @param id Region node ID that finished updating, defaults to current view
+     * @param inner Whether this is an internal framework call
+     */
     endUpdate: (id?: string, inner?: boolean) => void;
+    /**
+     * Wrap async callback to ensure it only executes if view is not destroyed.
+     * In SPAs, async callbacks (e.g., setTimeout, AJAX) may execute after view is destroyed,
+     * causing errors when manipulating DOM.
+     * After wrapping with `wrapAsync`, framework automatically checks view state and only executes callback if view is alive.
+     * @param fn Callback function to wrap
+     * @param context `this` binding for callback execution, defaults to view itself
+     */
     wrapAsync: <Fn extends AnyFunc>(fn: Fn, context?: unknown) => (...args: Parameters<Fn>) => ReturnType<Fn> | undefined;
+    /**
+     * Listen for URL bar changes, supports two calling modes:
+     * - `observeLocation("page,size", true)` pass parameter keys (comma-separated) and whether to observe path
+     * - `observeLocation({ params: ["page", "size"], path: true })` pass config object
+     * View automatically re-renders when observed parameters or path change.
+     * @param params Parameter keys to observe, supports comma-separated string, string array, or config object
+     * @param observePath Whether to observe path changes
+     */
     observeLocation: (params: string | string[] | Record<string, unknown>, observePath?: boolean) => void;
+    /**
+     * Observe data changes for specified keys in State.
+     * View automatically re-renders when observed keys are updated via `State.digest()`.
+     * @param keys Comma-separated key string or string array
+     */
     observeState: (keys: string | string[]) => void;
+    /**
+     * Hand over resource to current view for lifecycle management.
+     * Framework automatically calls resource's destroy method at appropriate time when view unmounts or re-renders.
+     * @param key Unique key for managed resource; if key already manages different resource, old resource is auto-destroyed
+     * @param resource Resource object to manage
+     * @param destroyOnRender Whether to auto-destroy resource when render method is called; Service instances typically need auto-destroy on render
+     */
     capture: (key: string, resource?: unknown, destroyOnRender?: boolean) => unknown;
+    /**
+     * Release managed resource, returns the resource object regardless of destruction state.
+     * @param key Managed resource key
+     * @param destroy Whether to destroy resource (call its destroy method), defaults to true
+     */
     release: (key: string, destroy?: boolean) => unknown;
+    /**
+     * Set leave prompt, e.g., when form has unsaved changes.
+     * Can prompt user to choose between leaving directly or saving before leaving.
+     * Framework calls condition function during route changes (change phase) and page unloads (beforeunload).
+     * Navigation is prevented if condition returns true.
+     * @param message Leave prompt message
+     * @param condition Function to determine whether to show leave prompt; returns true to prevent navigation
+     */
     leaveTip: (message: string, condition: () => boolean) => void;
-    assign: (options?: unknown) => boolean | undefined;
+    /**
+     * Assign method for incremental DOM updates.
+     * Framework uses VDOM diff (in-memory real DOM diff) to update only changed portions,
+     * automatically handling child view mounting and unmounting.
+     * Returns true if DOM changed, undefined if no change.
+     * @param options Incremental update config, used internally by framework
+     */
+    assign?: (options?: unknown) => boolean | undefined;
+    /**
+     * Triggered when view is destroyed.
+     */
+    onDestroy?: (e?: ChangeEvent) => void;
+    /**
+     * Triggered when render method is called.
+     */
+    onRender?: (e?: ChangeEvent) => void;
+    /**
+     * Inherit View to create new view subclass.
+     * Supports props.make constructor, props.mixins, and event methods (e.g., `'name<click>'`).
+     * @param props Prototype object containing init, render, and other methods
+     * @param statics Object of static methods or properties
+     */
+    extend?<TProps = object, TStatics = object>(props?: ExtendThisType<TProps & ViewInterface>, statics?: TStatics): ViewInterface & TStatics;
+    /**
+     * Merge multiple mixin objects into View prototype.
+     * Existing properties are not overwritten; event method conflicts are automatically merged into sequential calls.
+     * @param args Mixin object list
+     */
+    merge?(...args: ExtendThisType<ViewInterface>[]): ViewInterface;
+    navigate?: (path: string, params?: Record<string, unknown>) => void;
 }
-/** Minimal Frame interface needed by View */
-interface FrameLike {
+type ExtendThisType<T> = Record<string, unknown> & ThisType<T>;
+/**
+ * Minimal Frame interface needed by View.
+ * Frame (View Frame) is a view container managing view mount, unmount, and parent-child hierarchy.
+ * Each Frame corresponds to one DOM node, associated with view via v-lark attribute.
+ */
+interface FrameInterface extends EventEmitterInterface<FrameInterface> {
+    /**
+     * DOM node ID where Frame resides.
+     */
     id: string;
-    parentId: string | undefined;
-    unmountZone: (zoneId?: string, inner?: boolean) => void;
-    mountZone: (zoneId?: string, inner?: boolean) => void;
-    mountFrame: (frameId: string, viewPath: string, viewInitParams?: Record<string, unknown>) => FrameLike;
+    /**
+     * View module path currently rendered by this Frame, e.g., "app/views/default".
+     */
+    readonly viewPath?: string;
+    /**
+     * Parent Frame ID, undefined if this is a top-level Frame.
+     */
+    readonly parentId: string | undefined;
+    /**
+     * Mount view to current Frame.
+     * Framework loads view class, creates instance, and renders view.
+     * @param viewPath View module path, e.g., "app/views/default"
+     * @param viewInitParams Parameters passed during view initialization, accessible in view's init method
+     */
+    mountView(viewPath: string, viewInitParams?: Record<string, unknown>): void;
+    /**
+     * Unmount view from current Frame, triggers view's destroy event and cleans up resources.
+     */
+    unmountView(): void;
+    /**
+     * Mount child Frame on specified DOM node and render view.
+     * @param frameId DOM node ID for rendering
+     * @param viewPath View path
+     * @param viewInitParams Parameters passed during view initialization
+     */
+    mountFrame: (frameId: string, viewPath: string, viewInitParams?: Record<string, unknown>) => FrameInterface;
+    /**
+     * Unmount child Frame from specified DOM node.
+     * @param id DOM node ID, defaults to current Frame if omitted
+     */
     unmountFrame: (id?: string, inner?: boolean) => void;
-    view: ViewInstance | undefined;
-    children: () => string[];
+    /**
+     * Render all child views under specified node (scans v-lark attributes and mounts).
+     * @param zoneId DOM node ID, defaults to current Frame
+     * @param inner Whether this is an internal framework call
+     */
+    mountZone: (zoneId?: string, inner?: boolean) => void;
+    /**
+     * Unmount all child views under specified node.
+     * @param zoneId DOM node ID, defaults to current Frame
+     */
+    unmountZone: (zoneId?: string, inner?: boolean) => void;
+    /**
+     * Get ancestor Frame, defaults to parent Frame (level=1).
+     * @param level Levels to traverse upward, defaults to 1
+     */
+    parent(level?: number): FrameInterface | undefined;
+    /**
+     * Invoke specified method on view in current Frame.
+     * If view is not rendered yet, invocation is deferred until render completes.
+     * @param name Method name
+     * @param args Arguments array passed to method
+     */
     invoke: (name: string, args?: unknown[]) => unknown;
+    /**
+     * Triggered when all descendant views have been created.
+     */
+    onCreated?: (e?: ChangeEvent) => void;
+    /**
+     * Triggered when descendant views change.
+     */
+    onAlter?: (e?: ChangeEvent) => void;
+    /**
+     * Get Frame instance by ID, returns undefined if not exists.
+     * @param id Frame's DOM node ID
+     */
+    get?(id: string): FrameInterface | undefined;
+    /**
+     * Get all Frame instances map for current page.
+     */
+    getAll?(): Map<string, FrameInterface>;
+    /**
+     * Triggered when Frame is created and registered.
+     */
+    onAdd?: (e?: FrameStaticEvent) => void;
+    /**
+     * Triggered when Frame is destroyed and unregistered.
+     */
+    onRemove?: (e?: FrameStaticEvent) => void;
+    view: ViewInterface | undefined;
+    /**
+     * Get ID array of all child Frames for current Frame.
+     * Note: ID positions in array are not fixed.
+     */
+    children: () => string[];
     invokeList: FrameInvokeEntry[];
-    on: (event: string, handler: AnyFunc) => FrameLike;
-    off: (event: string, handler?: AnyFunc) => FrameLike;
-    fire: (event: string, data?: Record<string, unknown>) => FrameLike;
 }
-/** Minimal Updater interface needed by View */
-interface UpdaterLike {
+/**
+ * Minimal Updater interface needed by View.
+ * View updater responsible for view data binding and data/page updates.
+ * Each View instance has an Updater, triggering data/page updates via set/digest.
+ * Internally executes complete pipeline: template rendering → VDOM diff (in-memory real DOM diff) → DOM operations.
+ */
+interface UpdaterInterface {
+    /**
+     * Get data that has been set.
+     * Returns complete data object if key is omitted, otherwise returns value for specified key.
+     * @param key Data key name, omitted returns complete data object
+     */
     get: <T = unknown>(key?: string) => T;
-    set: (data: Record<string, unknown>, excludes?: Set<string>) => UpdaterLike;
-    digest: (data?: Record<string, unknown>, excludes?: Set<string>) => void;
-    /** Save a snapshot of current data for altered() detection */
-    snapshot: () => this;
-    /** Check if data has changed since last snapshot */
+    /**
+     * Set data and track changed keys.
+     * After set, must explicitly call `digest()` to commit changes to page.
+     * Returns this for chaining.
+     * @param data Data object, e.g., `{ a: 1, b: 2 }`
+     * @param excludes Set of keys to exclude from change tracking
+     */
+    set: (data: Record<string, unknown>, excludes?: ReadonlySet<string>) => UpdaterInterface;
+    /**
+     * Trigger page re-render.
+     * After set, must explicitly call `digest()` to commit changes to page.
+     * Internally executes complete pipeline: template rendering → VDOM diff (in-memory real DOM diff) → DOM operations.
+     * @param data Optional data object, if provided calls `set()` first to set data
+     * @param excludes Set of keys to exclude from change tracking
+     * @param callback Callback executed after render completes
+     */
+    digest: (data?: Record<string, unknown>, excludes?: ReadonlySet<string>, callback?: () => void) => void;
+    /**
+     * Save a snapshot of current data for altered() detection.
+     * Works with `altered()` method to detect whether data has changed.
+     */
+    snapshot: () => UpdaterInterface;
+    /**
+     * Check if data has changed since last snapshot.
+     * Returns undefined if `snapshot()` has not been called.
+     */
     altered: () => boolean | undefined;
     /** Ref data for template rendering */
     refData: Record<string, unknown>;
+    /**
+     * Translate raw reference data starting with @ symbol in template.
+     * Replaces `{{@refData}}` with actual value from refData.
+     * @param data Reference data to translate
+     */
+    translate(data: unknown): unknown;
+    /**
+     * Parse expression string.
+     * @param expr Expression string to parse
+     */
+    parse(expr: string): unknown;
+}
+/**
+ * Data payload interface wrapping API request response data, providing read/write methods.
+ * Payload instances are created internally by Service, developers access via all/one/save callbacks.
+ */
+interface PayloadInterface {
+    /**
+     * Get data from Payload by key.
+     * @param key Data key name
+     */
+    get<T = unknown>(key: string): T;
+    /**
+     * Set data to Payload, supports three calling modes:
+     * - Key-value pair: `payload.set("name", "value")`
+     * - Data object: `payload.set({ name: "value" })`
+     * - Endpoint metadata object (for internal framework use)
+     * Returns this for chaining.
+     * @param keyOrData Key/value string, data object, or endpoint metadata object
+     * @param value Value when first parameter is a key
+     */
+    set(keyOrData: string | Record<string, unknown> | ServiceMetaEntry, value?: unknown): PayloadInterface;
+    data: Record<string, unknown>;
+    cacheInfo?: ServiceCacheInfo;
+}
+/**
+ * Change event object.
+ */
+interface ChangeEvent {
+    /**
+     * Event type.
+     */
+    readonly type: string;
+    /**
+     * Set of changed data keys. Use `keys.has(name)` to check membership.
+     */
+    readonly keys?: ReadonlySet<string>;
+}
+/**
+ * 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.
+ *
+ * Use State for SIMPLE cross-view data (lightweight shared values: counters,
+ * toggles, page title, session info, etc.). For COMPLEX reactive state —
+ * handlers, derived data, multi-instance isolation, or Proxy-based fine-grained
+ * dependency tracking — use `defineStore` instead.
+ */
+interface StateInterface extends EventEmitterInterface<StateInterface> {
+    /**
+     * Get data from global state, returns complete state object if key is omitted.
+     * @param key Data key name, omitted returns complete state object
+     */
+    get<T = unknown>(key?: string): T;
+    /**
+     * Set global state data.
+     * After set, must explicitly call `digest()` to dispatch changed event and notify views to update.
+     * @param data Data object, e.g., `{ a: 1, b: 2 }`
+     * @param excludes Set of keys to exclude from change tracking
+     */
+    set(data: Record<string, unknown>, excludes?: ReadonlySet<string>): this;
+    /**
+     * Clean data for specified keys in State, can only be used in view's mixins.
+     * For example `mixins: [State.clean("a,b")]`.
+     * Keys registered via this method are automatically cleaned when view is destroyed,
+     * and corresponding key reference counts are decremented; data is auto-deleted when count reaches zero.
+     * @param keys Comma-separated key string
+     * @returns Object with make method, called by mixins mechanism
+     */
+    clean(keys: string): {
+        make: AnyFunc;
+    };
+    /**
+     * Detect data changes and dispatch changed event.
+     * After set, must explicitly call `digest()` to dispatch changed event and notify views to update.
+     * @param data Optional data object, if provided calls `set()` first to set data
+     * @param excludes Set of keys to exclude from change tracking
+     */
+    digest(data?: Record<string, unknown>, excludes?: ReadonlySet<string>): void;
+    /**
+     * Get the set of keys changed in the most recent digest.
+     */
+    diff: () => ReadonlySet<string>;
+    onChanged?: (e?: ChangeEvent) => void;
 }
 interface ServiceOptions {
     /** Request URL */
@@ -227,14 +1249,14 @@ interface ServiceOptions {
     /** Request params */
     params?: Record<string, unknown>;
     /** HTTP method */
-    method?: "GET" | "POST" | "PUT" | "DELETE";
+    method?: "GET" | "POST" | "PUT" | "DELETE" | string;
     /** Cache: true for default, number for TTL */
     cache?: boolean | number;
     /** POST data */
     data?: unknown;
 }
-interface BagEntry {
-    /** Bag data */
+interface PayloadEntry {
+    /** Payload data */
     data: Record<string, unknown>;
 }
 interface ServiceEntry {
@@ -244,8 +1266,8 @@ interface ServiceEntry {
     url: string;
     /** Cache time in ms, 0 = no cache */
     cacheTime: number;
-    /** Bag instance */
-    bag?: BagEntry;
+    /** Payload instance */
+    payload?: PayloadEntry;
     /** Whether loading */
     loading?: boolean;
     /** Error info */
@@ -253,26 +1275,151 @@ interface ServiceEntry {
 }
 /** Pending cache entry for deduplication (internal to Service) */
 interface PendingCacheEntry extends Array<unknown> {
-    /** Reference to the pending Bag entity */
-    e?: unknown;
+    /** Reference to the pending Payload entity */
+    entity?: unknown;
 }
+/**
+ * Endpoint metadata configuration for registering an API endpoint with Service.
+ * Each meta describes endpoint's URL, cache strategy, before/after interceptors, etc.
+ */
 interface ServiceMetaEntry {
-    /** Endpoint name */
+    /**
+     * Endpoint name,
+     * Unique name for endpoint metadata, must be unique within same Service.
+     */
     name: string;
-    /** URL */
+    /** Request URL, required. */
     url: string;
-    /** Cache TTL in ms, 0 = no cache */
+    /**
+     * Cache TTL in ms, 0 = no cache.
+     * Cache validity time in milliseconds.
+     * 0 means no caching.
+     * Greater than 0 means cache TTL, reuse cached data within this time range.
+     */
     cache?: number;
-    /** Before-fetch hook */
-    before?: AnyFunc;
-    /** After-fetch hook */
-    after?: AnyFunc;
-    /** Clean keys on destroy */
-    cleans?: string;
+    /**
+     * Before-fetch hook,
+     * Hook function called before request is sent, can process request data.
+     * `this` points to current Payload instance.
+     * @param payload Data carrier for current request
+     */
+    before?: (this: PayloadInterface, payload: PayloadInterface) => void;
+    /**
+     * After-fetch hook.
+     * Hook function called after request succeeds, before data is passed to view.
+     * Can process response data in this method.
+     * `this` points to current Payload instance.
+     * @param payload Data carrier for current request
+     */
+    after?: (this: PayloadInterface, payload: PayloadInterface) => void;
+    /** Clean keys on destroy,
+     * Comma-separated endpoint name string for clearing other endpoints' cache.
+     * For example, if an endpoint creates new data,
+     * after successful call, should clear all data-fetching endpoints' cache,
+     * otherwise new data cannot be retrieved.
+     */
+    cleanKeys?: string;
     /** Additional properties */
     [key: string]: unknown;
 }
-/** Cache info attached to Bag entity */
+interface ServiceInternals {
+    metaList: Record<string, ServiceMetaEntry>;
+    payloadCache: CacheInterface<PayloadInterface>;
+    pendingCacheKeys: Record<string, PendingCacheEntry>;
+    syncFn: (payload: PayloadInterface, callback: () => void) => void;
+    staticEmitter: EventEmitterInterface;
+}
+interface ServiceInterface {
+    id: string;
+    destroyed: number;
+    busy: number;
+    taskQueue: AnyFunc[];
+    prevArgs: unknown[];
+    emitter: EventEmitterInterface;
+    internals: ServiceInternals;
+    /**
+     * Send all requests in parallel, execute done callback when all requests complete (success or failure).
+     * If endpoint specifies cache and cache is valid, uses cached data directly.
+     * @param metaList Endpoint name string, params object, or array of them
+     * @param done Callback when all requests complete, first param is error array, followed by each endpoint's Payload
+     */
+    all(metaList: string | Record<string, unknown> | (string | Record<string, unknown>)[], done: AnyFunc): ServiceInterface;
+    /**
+     * Execute callback after each request succeeds, callback may be called multiple times.
+     * @param metaList Endpoint name string, params object, or array of them
+     * @param done Callback
+     */
+    one(attrs: string | Record<string, unknown> | (string | Record<string, unknown>)[], done: AnyFunc): ServiceInterface;
+    /**
+     * Similar to all, but always skips cache and forces actual requests.
+     * @param metaList Endpoint name string, params object, or array of them
+     * @param done Callback
+     */
+    save(metaList: string | Record<string, unknown> | (string | Record<string, unknown>)[], done: AnyFunc): ServiceInterface;
+    /**
+     * Queue task for execution, executes next task after previous all/one/save task completes, similar to Promise chain.
+     * @param callback Callback invoked after task completes
+     */
+    enqueue(callback: AnyFunc): ServiceInterface;
+    /**
+     * Dequeue and execute next task in queue.
+     */
+    dequeue(...args: unknown[]): void;
+    /**
+     * Destroy current Service instance, cannot send new requests or invoke callbacks after destruction.
+     */
+    destroy(): void;
+    /**
+     * Add endpoint metadata, register one or more API endpoints.
+     * @param metaList Endpoint metadata array, or single metadata object
+     */
+    add(attrs: ServiceMetaEntry | ServiceMetaEntry[]): void;
+    /**
+     * Get metadata object.
+     * @param attrs Endpoint metadata object or name string
+     */
+    meta(attrs: string | Record<string, unknown>): ServiceMetaEntry;
+    /**
+     * Create Payload object from endpoint metadata.
+     * @param meta Endpoint metadata object or name string
+     */
+    create(meta: Record<string, unknown>): PayloadInterface;
+    /**
+     * Get or create Payload object from cache.
+     * @param meta Endpoint metadata object
+     * @param createNew Whether to create new Payload object; if false, prioritizes getting from cache
+     */
+    get(meta: Record<string, unknown>, createNew?: boolean): {
+        entity: PayloadInterface;
+        needsUpdate: boolean;
+    };
+    /**
+     * Get Payload object from cache, returns undefined if cache doesn't exist or has expired.
+     * @param meta Endpoint metadata object
+     */
+    cached(meta: Record<string, unknown>): PayloadInterface | undefined;
+    /**
+     * Clear cached data for specified endpoint.
+     * @param names Comma-separated endpoint name string or string array
+     */
+    clear(names: string | string[]): void;
+    /**
+     * Inherit to create new Service subclass, bind custom data sync function.
+     * @param sync Method to sync data, typically exchanges data with server
+     * @param cacheMax Maximum cache entries
+     * @param cacheBuffer Cache buffer size
+     */
+    extend(newSyncFn: (payload: PayloadInterface, callback: () => void) => void, newCacheMax?: number, newCacheBuffer?: number): ServiceInterface;
+    /**
+     * Triggered before endpoint sends request.
+     */
+    onBegin?: (e?: ServiceEvent) => void;
+    /**
+     * Triggered when endpoint request completes, whether success or failure.
+     */
+    onEnd?: (e?: ServiceEvent) => void;
+}
+/** Cache info attached to Payload entity */
 interface ServiceCacheInfo {
     /** Endpoint name */
     name: string;
@@ -285,34 +1432,284 @@ interface ServiceCacheInfo {
     /** Timestamp when cached */
     time: number;
 }
+interface FrameworkInterface {
+    /**
+     * Read framework configuration.
+     * - Without arguments: returns the complete config object.
+     * - With a key: returns just `config[key]` (untyped — use a generic to
+     *   constrain the return type if you know the key's shape).
+     *
+     * `getConfig` is a pure read — call `setConfig(patch)` to mutate.
+     */
+    getConfig(): FrameworkConfig;
+    getConfig<T = unknown>(key: string): T | undefined;
+    /**
+     * Merge a patch into the framework configuration and return the merged
+     * config object. Replaces the dual-purpose overload of `config()`.
+     */
+    setConfig<T extends object = Partial<FrameworkConfig>>(patch: Partial<FrameworkConfig> & T): FrameworkConfig & T;
+    /**
+     * @deprecated Use `getConfig()` / `getConfig(key)` for reads and
+     * `setConfig(patch)` for writes. The overloaded `config()` blurred the
+     * two and confused TypeScript inference; the split is a drop-in upgrade.
+     */
+    config<T extends object = Partial<FrameworkConfig>>(cfg?: Partial<FrameworkConfig> & T): FrameworkConfig & T;
+    /** @deprecated See above. */
+    config(key: string): unknown;
+    /**
+     * App initialization entry point, starts framework and renders root view.
+     * After invocation: merge config → bind route events → create root Frame → mount default view.
+     * @param cfg Config object
+     */
+    boot(cfg: FrameworkConfig): void;
+    /**
+     * Convert array to hash map object.
+     * - Simple array: `Framework.toMap([1,2,3])` => `{1:1, 2:1, 3:1}`
+     * - Object array: `Framework.toMap([{id:20},{id:30}], 'id')` => `{20:{id:20}, 30:{id:30}}`
+     * @param list Source array
+     * @param key Use object's key value from array as map key
+     */
+    toMap<T>(list: T[] | null | undefined, key?: keyof T): Record<string, T | number>;
+    /**
+     * Execute methods in try-catch manner, catches exceptions.
+     * Returns return value of last successfully executed method.
+     * @param fns Function or function array
+     * @param args Arguments array passed to functions
+     * @param context `this` binding during function execution
+     */
+    toTry(fns: AnyFunc | AnyFunc[], args?: unknown[], context?: unknown): unknown;
+    /**
+     * Convert path and params to URL string.
+     * Example: `Framework.toUrl('/xxx/', {a:'b',c:'d'})` => `/xxx/?a=b&c=d`
+     * @param path Path string
+     * @param params Params object
+     * @param keepEmpty Set of keys whose empty values should be preserved
+     */
+    toUrl(path: string, params?: Record<string, unknown>, keepEmpty?: Set<string>): string;
+    /**
+     * Parse URL string to path and params object.
+     * Example: `Framework.parseUrl('/xxx/?a=b&c=d')` => `{path:'/xxx/', params:{a:'b',c:'d'}}`
+     * @param url URL string
+     */
+    parseUrl(url: string): ParsedUri;
+    /**
+     * Merge source object properties into target object.
+     * @param target Target object
+     * @param sources One or more source objects
+     */
+    mix<T extends object>(target: T, ...sources: Partial<T>[]): T;
+    /**
+     * Check if object has specified own property (safe hasOwnProperty).
+     * @param owner Object to check, supports undefined/null
+     * @param prop Property key name
+     */
+    has<T extends object>(owner: T | undefined | null, prop: PropertyKey): boolean;
+    /**
+     * Get enumerable property keys of object as array.
+     * @param src Source object
+     */
+    keys<T extends object>(src: T): string[];
+    /**
+     * Check if one DOM node is contained within another.
+     * Returns true if both nodes are the same.
+     * @param node Node or node ID
+     * @param container Container node or node ID
+     */
+    inside(node: HTMLElement | string, container: HTMLElement | string): boolean;
+    /**
+     * Shorthand for document.getElementById.
+     * Returns directly if Element is passed.
+     * @param id Node ID or Element object
+     */
+    node(id: string | Element | null): Element | null;
+    /**
+     * Ensure DOM element has an ID, auto-generates one if missing.
+     * Returns element's ID.
+     * @param node DOM element object
+     */
+    nodeId(node: HTMLElement): string;
+    /**
+     * Load modules using configured module loader.
+     * @param names Module names, supports string or string array
+     * @param callback Callback after modules are loaded
+     */
+    use(names: string | string[], callback?: (...modules: unknown[]) => void): void;
+    /**
+     * Protect object from direct modification in debug mode.
+     * Wraps data object with Proxy, intercepts read/write operations, warns to use State.set/digest for state management.
+     * Only effective when `window.__lark_Debug` is true.
+     * @param o Object to protect
+     */
+    guard<T extends object>(o: T): T;
+    /**
+     * Dynamically inject CSS styles into page. Returns cleanup function to remove injected styles.
+     * Supports single and batch injection.
+     * - `Framework.applyStyle("my-style", "body { color: red; }")` single injection
+     * - `Framework.applyStyle(["style1", "css1", "style2", "css2"])` batch injection
+     * @param styleIdOrPairs Style unique key or [id1, css1, id2, css2, ...] batch array
+     * @param cssText CSS style string (only used when first param is string)
+     */
+    applyStyle(styleIdOrPairs: string | string[], cssText?: string): () => void;
+    /**
+     * Generate globally unique identifier (GUID).
+     * @param prefix GUID prefix, defaults to "lark-"
+     */
+    guid(prefix?: string): string;
+    /**
+     * Create async callback validity marker.
+     * Returns a check function; if host object is unmarked (e.g., view re-rendered), check function returns false, preventing expired async callbacks from executing.
+     * Typical usage: `const check = Framework.mark(this, 'render'); setTimeout(() => { if (check()) ... })`
+     * @param host Host object (usually view instance)
+     * @param key Marker key name (usually "render" or specific async operation identifier)
+     */
+    mark(host: object, key: string): () => boolean;
+    /**
+     * Delay wait, Promise-based setTimeout wrapper.
+     * @param time Delay time in milliseconds
+     */
+    delay(time: number): Promise<void>;
+    /**
+     * Whether framework has booted
+     */
+    isBooted(): boolean;
+    /**
+     * Invalidate (unmark) async callback markers for a host object.
+     * Typically called when a view is re-rendered or destroyed.
+     * @param host The host object whose markers should be invalidated
+     */
+    unmark(host: object): void;
+    /**
+     * Fire a custom DOM event on a target element.
+     * @param target Target element or EventTarget
+     * @param eventType Event type string
+     * @param eventInit CustomEvent init options
+     */
+    dispatch(target: EventTarget, eventType: string, eventInit?: CustomEventInit): void;
+    /**
+     * Execute a function in try-catch with chunked scheduling.
+     * @param fn Function to execute
+     * @param args Arguments to pass
+     * @param context `this` context
+     */
+    task(fn: AnyFunc, args?: unknown[], context?: unknown): void;
+    /**
+     * Wait for all views in a zone to be rendered.
+     * Returns WAIT_OK if rendered, WAIT_TIMEOUT_OR_NOT_FOUND if timeout or not found.
+     * @param viewId Zone view ID
+     * @param timeout Timeout in milliseconds (default: 30000)
+     */
+    waitZoneViewsRendered(viewId: string, timeout?: number): Promise<number>;
+    /** Wait result: views rendered successfully */
+    WAIT_OK: number;
+    /** Wait result: timeout or view not found */
+    WAIT_TIMEOUT_OR_NOT_FOUND: number;
+    /**
+     * Base class with EventEmitter.
+     * Inherits EventEmitter for use as a base class in the framework.
+     */
+    Base: typeof EventEmitter;
+    /**
+     * View class.
+     * Use `View.extend()` to create subclasses.
+     */
+    View: typeof View;
+    /**
+     * Cache class.
+     * Use `new Cache()` to create cache instances.
+     */
+    Cache: typeof Cache;
+    /**
+     * Global state object.
+     */
+    State: StateInterface;
+    /**
+     * Router object.
+     */
+    Router: RouterInterface;
+    /**
+     * Frame class.
+     * Frame tree for view lifecycle management. Do not extend or instantiate directly.
+     */
+    Frame: typeof Frame;
+}
+/**
+ * Framework configuration interface, global config passed to app during `Framework.boot()`.
+ * All config items can be accessed at runtime via `Framework.config('key')`.
+ */
 interface FrameworkConfig {
-    /** Root element ID */
+    /**
+     * Root element ID.
+     * DOM root node ID where root view resides, framework renders root view within this node.
+     * This field is required, defaults to "root".
+     */
     rootId: string;
-    /** Default view path */
+    /**
+     * Default view path.
+     * Default root view path to load when URL doesn't match any route.
+     */
     defaultView?: string;
-    /** Default path when no hash present */
+    /**
+     * Default path when no hash present,
+     * Path used when URL hash is empty, defaults to "/".
+     */
     defaultPath?: string;
-    /** Route mapping: path -> view */
+    /**
+     * Route mapping: path -> view.
+     * Mapping relationship between paths and views.
+     * - Simple mapping: `{ "/home": "app/views/home" }`
+     * - Config mapping: `{ "/detail": { view: "app/views/detail", title: "Detail" } }`
+     * Use rewrite config item for path rewriting logic.
+     */
     routes?: Record<string, string | RouteViewConfig>;
     /** Hashbang prefix */
     hashbang?: string;
-    /** Error handler */
+    /**
+     * Error handler.
+     * Global error handling function, framework uses try-catch to execute some core logic.
+     * When errors are thrown, allows developers to catch them via this config item.
+     * Note: Do not re-throw any errors in this method.
+     */
     error?: (error: Error) => void;
-    /** Extensions to load */
-    exts?: string[];
+    /**
+     * Extensions to load.
+     * Array of extension view paths to load during app startup.
+     * These extension views are loaded before app initialization.
+     */
+    extensions?: string[];
     /** Init module to load */
-    ini?: string;
+    initModule?: string;
     /** Rewrite function for routes */
     rewrite?: (path: string, params: Record<string, string>, routes: Record<string, string>) => string;
-    /** Unmatched view (404) */
+    /**
+     * Unmatched view (404).
+     * View path to use when no matching view is found in routes, e.g., 404 page.
+     */
     unmatchedView?: string;
-    /** Module require function */
-    require?: (names: string[], params?: Record<string, unknown>) => Promise<unknown> | undefined;
+    /**
+     * Module require function for asynchronous view loading.
+     * Called by `Framework.use()` when a view class is not found in the registry.
+     * Integrate with Webpack Module Federation or other dynamic loading strategies.
+     *
+     * @param names - Array of module names to load (e.g., `["remote-app/views/home"]`)
+     * @param params - Optional parameters passed to the module initializer
+     * @returns Promise resolving to an array of loaded modules, or undefined if not available
+     */
+    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 */
+    /**
+     * Project name of the current application.
+     * Used by the micro-frontend bridge to determine if a view path
+     * belongs to the current project or a remote project.
+     */
+    projectName?: string;
+    /**
+     * Cross-site (micro-frontend) configuration list.
+     * Defines remote projects that can be loaded via Module Federation.
+     * Also accessible via `window.crossConfigs` for build-time injection.
+     */
+    crossConfigs?: CrossSiteConfig[];
+    /** Dynamic config access, custom config items */
     [key: string]: unknown;
 }
 interface RouteViewConfig {
@@ -321,6 +1718,23 @@ interface RouteViewConfig {
     /** Additional properties merged into location */
     [key: string]: unknown;
 }
+/**
+ * Configuration for a remote (cross-site) project in the micro-frontend setup.
+ * Each entry defines how to load views from a different project via Module Federation.
+ */
+interface CrossSiteConfig {
+    /** Project name, used as the prefix in view paths (e.g., "remote-app" in "remote-app/views/home") */
+    projectName: string;
+    /**
+     * Remote source URL or Module Federation remote name.
+     * For Webpack MF: the remote entry URL (e.g., "remote_app@//cdn.example.com/remote-app/remoteEntry.js")
+     */
+    source: string;
+    /** Optional API host for the remote project */
+    apiHost?: string;
+    /** Optional business code for multi-tenant scenarios */
+    bizCode?: string;
+}
 /** Element with VDOM diff cached compare key */
 interface VdomElement extends Element {
     /** Whether compare key is cached */
@@ -333,7 +1747,7 @@ interface VdomElement extends Element {
 /** Element with frame binding */
 interface FrameBoundElement extends HTMLElement {
     /** Frame instance bound to this element */
-    frame?: FrameLike;
+    frame?: FrameInterface;
     /** Whether frame is bound (1 = bound) */
     frameBound?: number;
     /** View rendered flag */
@@ -343,6 +1757,15 @@ interface FrameBoundElement extends HTMLElement {
     /** Range element guid */
     rangeElementGuid?: number;
 }
+/** Options for compileTemplate() */
+interface CompileOptions {
+    /** Enable debug mode with line tracking (default: false) */
+    debug?: boolean;
+    /** Global variable names to destructure from $$ (refData) */
+    globalVars?: string[];
+    /** File path for debug error messages (default: undefined) */
+    file?: string;
+}
 
 /**
  * Lark framework utility functions.
@@ -350,8 +1773,6 @@ interface FrameBoundElement extends HTMLElement {
 
 /** Check if value is a plain object (not null, not array, typeof object) */
 declare function isPlainObject(value: unknown): value is Record<string, unknown>;
-/** Check if value is an array */
-declare const isArray: (arg: any) => arg is any[];
 /** Check if value is primitive or function (not a complex object) */
 declare function isPrimitiveOrFunc(value: unknown): boolean;
 /** Check if value is primitive (not object, not function) */
@@ -361,7 +1782,7 @@ declare function generateId(prefix?: string): string;
 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;
+declare function hasOwnProperty<T extends object>(owner: T | undefined | null, prop: PropertyKey): boolean;
 /** Get object keys (own enumerable) */
 declare function keys<T extends object>(obj: T): string[];
 /** Assign properties from sources to target (like Object.assign but safer) */
@@ -370,16 +1791,12 @@ declare function assign<T extends object>(target: T, ...sources: Partial<T>[]):
  * Execute functions in try-catch, ignoring errors.
  * Returns the result of the last successfully executed function.
  */
-declare function funcWithTry(fns: AnyFunc | AnyFunc[], args: unknown[], context: unknown, configError: (e: unknown) => void): unknown;
+declare function funcWithTry(fns: AnyFunc | AnyFunc[], args: unknown[], context: unknown, configError?: (e: unknown) => void): unknown;
 /**
  * Set newData into oldData, tracking changed keys.
  * Returns whether any value changed.
  */
-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 setData(newData: Record<string, unknown>, oldData: Record<string, unknown>, changedKeys: Set<string>, excludes: ReadonlySet<string>): boolean;
 declare function translateData(data: object, value: unknown): unknown;
 /** Get element by ID, or return the element itself if already an element */
 declare function getById(id: string | Element | null): Element | null;
@@ -395,13 +1812,16 @@ declare function nodeInside(a: string | HTMLElement, b: string | HTMLElement): b
 /**
  * Parse URI string into path and params object.
  * e.g. "/xxx/?a=b&c=d" => { path: "/xxx/", params: { a: "b", c: "d" } }
+ *
+ * The accumulator is function-local, so nested / re-entrant calls
+ * (e.g. invoking `parseUri` again inside a replace callback) are safe.
  */
 declare function parseUri(uri: string): ParsedUri;
 /**
  * Convert path and params to URI string.
  * e.g. toUri("/xxx/", { a: "b", c: "d" }) => "/xxx/?a=b&c=d"
  */
-declare function toUri(path: string, params: Record<string, unknown>, keepEmptyObject?: Record<string, number>): string;
+declare function toUri(path: string, params: Record<string, unknown>, keepEmpty?: ReadonlySet<string>): string;
 /**
  * Convert array to map/hash object.
  * For simple arrays, counts occurrences.
@@ -410,18 +1830,10 @@ declare function toUri(path: string, params: Record<string, unknown>, keepEmptyO
 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: {
+declare const RouterEvents: {
     CHANGE: string;
     CHANGED: string;
     PAGE_UNLOAD: string;
@@ -456,23 +1868,27 @@ declare function applyStyle(styleIdOrPairs: string | string[], css?: string): ()
 /**
  * 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.
+ * `mark(host, key)` returns a validity checker. The checker returns `false`
+ * once the host is unmarked (e.g. when a view re-renders or is destroyed),
+ * so stale async callbacks can short-circuit and skip work.
+ *
+ * State is stored in a module-level WeakMap, not on the host object, so
+ * `mark/unmark` never pollutes user objects with magic keys, never breaks
+ * on `Object.freeze`-ed inputs, and never shows up in debug snapshots.
  */
 /**
  * Create a mark for tracking async callback validity.
- * Returns a function that checks if the mark is still valid.
+ * Returns a function that returns true while 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
+ * @param host - Object to associate the mark with (typically a view)
+ * @param key  - Key to track (typically "render" or a specific async-op identifier)
  */
 declare function mark$1(host: object, key: string): () => boolean;
 /**
- * Clear all marks for a host object, invalidating all existing checkers.
+ * Clear all marks for a host object, invalidating every existing checker.
  * Called when a view re-renders or is destroyed.
  *
- * @param host - Object whose marks should be cleared
+ * @param host - Object whose marks should be invalidated
  */
 declare function unmark$1(host: object): void;
 
@@ -496,381 +1912,80 @@ declare function unmark$1(host: object): void;
  */
 declare function safeguard<T>(data: T, getter?: ((key: string) => void) | null, setter?: ((path: string, value: unknown) => void) | null, isRoot?: boolean): T;
 
-/**
- * Cache class with LFU-style eviction.
- * Keys are prefixed with SPLITTER for namespace isolation.
- *
- * @example
- * const cache = new Cache({ maxSize: 20, bufferSize: 5 });
- * cache.set('user', { name: 'Alice' });
- * const user = cache.get('user');
- * cache.has('user'); // true
- * cache.del('user');
- */
-declare class Cache<T = unknown> {
-    /** Cache entries array */
-    private entries;
-    /** Fast lookup: prefixed key -> entry */
-    private lookup;
-    /** Buffer size for eviction */
-    private readonly bufferSize;
-    /** Maximum cache size */
-    private readonly maxSize;
-    /** Total capacity (maxSize + bufferSize) */
-    private readonly capacity;
-    /** Callback when entry is removed */
-    private readonly onRemove?;
-    /** Sort comparator */
-    private readonly comparator;
-    constructor(options?: CacheOptions<T>);
-    /** Prefix a key with SPLITTER for namespace isolation */
-    private prefixKey;
-    /**
-     * Get a cached value by key.
-     * Updates frequency and timestamp for cache sorting.
-     */
-    get(key: string): T | undefined;
-    /**
-     * Iterate all cached values.
-     */
-    forEach(callback: (value: T | undefined) => void): void;
-    /**
-     * Set or update a cached value.
-     * If key already exists, updates value and increments frequency.
-     * If cache exceeds capacity, triggers eviction.
-     */
-    set(key: string, value: T): void;
-    /**
-     * Delete a cached entry.
-     */
-    del(key: string): void;
-    /**
-     * Check if a key exists in cache.
-     */
-    has(key: string): boolean;
-    /** Get current cache size */
-    get size(): number;
-    /** Clear all entries */
-    clear(): void;
-    /** Evict least-used entries from cache */
-    private evictEntries;
-}
-
-/**
- * Multi-cast event emitter class.
- *
- * @example
- * const emitter = new EventEmitter();
- * emitter.on('change', (data) => console.log(data));
- * emitter.fire('change', { key: 'value' });
- */
-declare class EventEmitter {
-    /** Event listeners: prefixed key -> listener array */
-    private listeners;
-    /**
-     * Bind event listener.
-     */
-    on(event: string, handler: AnyFunc): this;
-    /**
-     * Unbind event listener.
-     * If handler is provided, removes only that handler.
-     * If no handler, removes all handlers for the event.
-     */
-    off(event: string, handler?: AnyFunc): this;
-    /**
-     * Fire event, execute all bound handlers.
-     * Supports executing state management: handlers removed during
-     * execution are safely handled.
-     *
-     * @param event - Event name
-     * @param data - Event data (type property added automatically)
-     * @param remove - Whether to remove all handlers after firing
-     * @param lastToFirst - Whether to execute handlers in reverse order
-     */
-    fire(event: string, data?: Record<string, unknown>, remove?: boolean, lastToFirst?: boolean): this;
-}
-
 /** Mark framework as booted (called from Framework.boot) */
 declare function markBooted(): void;
-/**
- * Observable in-memory data object.
- * Provides get/set/digest/diff/clean methods for cross-view data sharing.
- */
-declare const State: {
-    get<T = unknown>(key?: string): T;
-    set(data: Record<string, unknown>, excludes?: Set<string>): typeof State;
-    digest(data?: Record<string, unknown>, excludes?: Set<string>): void;
-    diff(): Readonly<Record<string, number>>;
-    clean(keys: string): {
-        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;
-
-/**
- * Base View class.
- * Views are created via View.extend() and mounted by Frame.
- *
- */
-declare class View {
-    /** View ID (same as owner frame ID) */
-    id: string;
-    /** Owner frame */
-    owner: FrameLike | number;
-    /** Updater instance */
-    updater: UpdaterLike;
-    /** Signature: > 0 means active, incremented on render, 0 = destroyed */
-    signature: number;
-    /** Whether rendered at least once */
-    rendered?: boolean;
-    /** Whether view has template */
-    template?: AnyFunc | string;
-    /** Location observation config */
-    locationObserved: ViewLocationObserved;
-    /** Observed state keys */
-    observedStateKeys?: string[];
-    /** Resource map */
-    resources: ViewResourceMap;
-    /** Selector event map: eventType -> handler name list */
-    eventSelectorMap: ViewEventSelectorMap;
-    /** Event object map: eventType -> bitmask */
-    eventObjectMap: ViewEventObjectMap;
-    /** Global event list */
-    globalEventList: ViewGlobalEventEntry[];
-    /** Assign method reference */
-    assignMethod?: AnyFunc;
-    /** Whether endUpdate pending */
-    endUpdatePending?: number;
-    /** Internal event storage */
-    private _events;
-    /**
-     * Initialize view (called by Frame when mounting).
-     */
-    init(): void;
-    /**
-     * Render view template (called by Frame after init).
-     * Wrapped by View_WrapMethod to manage signature + resources.
-     *
-     * Default implementation calls updater.digest() which:
-     * 1. Executes the template function with current data
-     * 2. Runs VDOM diff against previous DOM
-     * 3. Applies DOM operations
-     * 4. Calls endUpdate to mount child frames
-     *
-     */
-    render(): void;
-    on(event: string, handler: AnyFunc): this;
-    off(event: string, handler?: AnyFunc): this;
-    fire(event: string, data?: Record<string, unknown>, remove?: boolean, lastToFirst?: boolean): this;
-    /**
-     * Notify view that HTML update is about to begin.
-     * Unmounts child frames in the update zone.
-     */
-    beginUpdate(id?: string): void;
-    /**
-     * Notify view that HTML update has ended.
-     * Mounts child frames in the update zone and runs deferred invokes.
-     */
-    endUpdate(id?: string, inner?: boolean): void;
-    /**
-     * Wrap an async callback to check view signature before executing.
-     * If the view has been re-rendered or destroyed, the callback is skipped.
-     */
-    wrapAsync<Fn extends AnyFunc>(fn: Fn, context?: unknown): (...args: Parameters<Fn>) => ReturnType<Fn> | undefined;
-    /**
-     * Observe location parameters or path changes.
-     * When observed keys change, render() is called automatically.
-     */
-    observeLocation(params: string | string[] | Record<string, unknown>, observePath?: boolean): void;
-    /**
-     * Observe State data keys for changes.
-     * When observed keys change via State.digest(), render() is called.
-     */
-    observeState(observedKeys: string | string[]): void;
-    /**
-     * Capture (register) a resource under a key.
-     * If a resource already exists at that key, it's destroyed first.
-     * When destroyOnRender=true, the resource is destroyed on next render call.
-     */
-    capture(key: string, resource?: unknown, destroyOnRender?: boolean): unknown;
-    /**
-     * Release a captured resource.
-     * If destroy=true, calls the resource's destroy() method.
-     */
-    release(key: string, destroy?: boolean): unknown;
-    /**
-     * Set up a leave confirmation for route changes and page unload.
-     */
-    leaveTip(message: string, condition: () => boolean): void;
-    /** Collected ctors from mixins */
-    static ctors?: AnyFunc[];
-    /**
-     * Extend View to create a new View subclass.
-     *
-     * Supports:
-     * - props.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<ViewInstance> & Record<string, unknown>, statics?: Record<string, unknown>): typeof View;
-    /**
-     * Merge mixins into View prototype.
-     */
-    static merge(...mixins: Record<string, unknown>[]): typeof View;
-}
+/**
+ * Observable in-memory data object.
+ * Provides get/set/digest/diff/clean methods for cross-view data sharing.
+ */
+declare const State: StateInterface;
 
 /**
- * Frame (View Frame) class for view lifecycle management.
- * Each frame owns a view and manages child frames.
+ * Hash-based router with two-phase change confirmation.
  *
+ * @example
+ * Router.to('/list', { page: 2 });
+ * const loc = Router.parse();
+ * const diff = Router.diff();
  */
-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;
-}
+declare const Router: RouterInterface;
+/** Mark framework as booted (called by Framework.boot) */
+declare function markRouterBooted(): void;
+
 /**
- * Register a View class for a given view path.
- * Called after module loading completes.
+ * Module loader: async view loading via FrameworkConfig.require or dynamic import.
+ *
+ * Extracted from framework.ts to avoid circular dependency with frame.ts.
+ * Both framework.ts and frame.ts import from this module.
+ */
+
+/** Framework configuration */
+declare const config: FrameworkConfig;
+/**
+ * Load modules via the configured require function or dynamic import fallback.
+ *
+ * Two calling conventions:
+ * 1. `use(name | name[], callback)`
+ * 2. `use(name | name[])` — returns Promise<unknown[]> (no callback)
+ *
+ * When `FrameworkConfig.require` is configured, delegates to it (e.g., Webpack Module Federation).
+ * When not configured, falls back to `dynamic import()` for ESM-based loading.
+ */
+declare function use(names: string | string[], callback?: (...modules: unknown[]) => void): Promise<unknown[]>;
+
+/**
+ * CrossSite: Micro-frontend bridge View for cross-project view loading.
+ *
+ * For Lark + Webpack Module Federation.
+ * Provides skeleton rendering, prepare preloading, assign reuse, and remote view mounting.
+ *
+ * Usage (in host project):
+ *   1. Register CrossSite as the bridge view for cross-site paths:
+ *      registerViewClass('cross-site', CrossSite);
+ *   2. Use v-lark="cross-site?view=remote-app/views/home&param=1" in template
+ *   3. CrossSite loads the remote project's prepare module, then mounts the actual view
  */
-declare function registerViewClass(viewPath: string, ViewClass: typeof View): void;
+
+/**
+ * Reset the projects map cache (useful when crossConfigs change at runtime).
+ */
+declare function resetProjectsMap(): void;
+/**
+ * CrossSite bridge View for micro-frontend integration.
+ *
+ * Flow:
+ * 1. CrossSite is mounted as a regular view (registered as "cross-site")
+ * 2. render() shows skeleton template with a child container
+ * 3. updateView() loads the remote project's prepare module
+ * 4. Once loaded, mounts the actual remote view into the child container
+ * 5. On re-assign (same view path), calls assign on the remote view instead of re-mounting
+ */
+declare const CrossSite: typeof View;
 
 /**
  * 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.
@@ -883,6 +1998,8 @@ declare function vdomGetNode(html: string, refNode: Element): Element;
 declare function vdomGetCompareKey(node: ChildNode): string | undefined;
 /**
  * Special diff for form elements (value, checked, selected).
+ * Form elements carry state on the DOM node (e.g. `input.value`) that isn't
+ * reflected in attributes, so we have to sync those properties separately.
  */
 declare function vdomSpecialDiff(oldNode: ChildNode, newNode: ChildNode): number;
 /**
@@ -892,11 +2009,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_?: ReadonlySet<string>): 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_?: ReadonlySet<string>): void;
 /**
  * Create an empty VDomRef for tracking diff operations.
  */
@@ -923,7 +2040,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 */
@@ -934,10 +2051,16 @@ declare class Updater implements UpdaterLike {
     private changedKeys;
     /** Whether data has changed since last digest */
     private hasChangedFlag;
-    /** Digesting queue: supports re-digest during digest */
+    /**
+     * Digesting queue: supports re-digest during digest.
+     * Holds pending callbacks; `null` is used as a sentinel marking the start
+     * of an active digest cycle, so `runDigest` can detect re-entrant calls.
+     */
     private digestingQueue;
-    /** Snapshot JSON string for altered() detection */
-    private snapshotJson;
+    /** Monotonically increasing version, bumped each time data actually changes. */
+    private version;
+    /** Snapshot of `version` taken by `snapshot()`, used by `altered()`. */
+    private snapshotVersion;
     constructor(viewId: string);
     /**
      * Get data by key.
@@ -948,7 +2071,7 @@ declare class Updater implements UpdaterLike {
      * Set data, tracking changed keys.
      * Returns this for chaining.
      */
-    set(data: Record<string, unknown>, excludes?: Set<string>): this;
+    set(data: Record<string, unknown>, excludes?: ReadonlySet<string>): this;
     /**
      * Detect changes and trigger VDOM re-render.
      *
@@ -960,291 +2083,263 @@ declare class Updater implements UpdaterLike {
      * 5. Call endUpdate on views that need re-rendering
      * 6. Support re-digest during digest via queue
      */
-    digest(data?: Record<string, unknown>, excludes?: Set<string>, callback?: () => void): void;
+    digest(data?: Record<string, unknown>, excludes?: ReadonlySet<string>, callback?: () => void): void;
     /**
      * Core digest execution.
      */
     private runDigest;
     /**
-     * Save a snapshot of current data for altered() detection.
+     * Save a snapshot of the current data version for `altered()` detection.
+     * Cheap O(1) — records the current monotonic version, no serialization.
      */
     snapshot(): this;
     /**
-     * Check if data has changed since last snapshot.
+     * Check whether data has changed since the last snapshot.
+     * Returns undefined when no snapshot has been taken yet.
      */
     altered(): boolean | undefined;
     /**
-     * Translate data references (SPLITTER-prefixed values).
+     * Translate a refData reference back to its original value.
+     *
+     * The ref protocol is `SPLITTER` + ascii decimal digits — the exact format
+     * emitted by `updaterRef`. We require that exact shape so a user-supplied
+     * string that merely begins with SPLITTER is never accidentally resolved
+     * (or mishandled as a "missing ref").
      */
     translate(data: unknown): unknown;
     /**
-     * Parse expression with data context.
+     * Resolve a dotted property path against refData.
+     *
+     * Only safe property-path syntax is supported: `a`, `a.b`, `a.b.c`.
+     * Numeric literals (e.g. `1`, `1.5`) are returned as numbers. Anything else
+     * returns `undefined` — we no longer evaluate arbitrary JavaScript via
+     * `new Function`, so the method is CSP-safe and cannot be used as an
+     * injection vector.
      */
     parse(expr: string): unknown;
     /**
-     * Get changed keys (for external inspection).
+     * Get the set of keys changed since the last digest (for external inspection).
      */
-    getChangedKeys(): Readonly<Record<string, number>>;
+    getChangedKeys(): ReadonlySet<string>;
 }
 
 /**
- * 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 copies of every per-type static field
+     * (`_metaList`, `_payloadCache`, `_pendingCacheKeys`, `_syncFn`,
+     * `_staticEmitter`, `_cacheMax`, `_cacheBuffer`) via `static override`.
+     * This is intentional: it ensures that endpoint metadata, cache state,
+     * in-flight dedup keys, and event subscribers are fully isolated between
+     * different Service types, even when one extends another.
+     *
+     * **Do not refactor these `static override` declarations away** — sharing
+     * them through prototype inheritance would let endpoints registered on one
+     * subclass leak into another, and the LFU cache evictions of one type
+     * would race with those of another.
      */
-    applyStyle: typeof applyStyle;
+    static extend(this: typeof Service, 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;
 };
 
 /**
- * @lark/framework Store
+ * Main framework object.
+ * Provides boot, config, and all global utility methods.
+ */
+declare const Framework: FrameworkInterface;
+
+/**
+ * @lark.js/mvc Store
  *
  * Reactive state management with Proxy-based dependency tracking.
  * Adapted for Lark / React / Node.js.
  *
+ * Store is the recommended choice for COMPLEX cross-view state:
+ * reactive handlers, derived data, multi-instance isolation (`multi()`),
+ * store-internal reactions (inner `observe`), and Proxy-based fine-grained
+ * dependency tracking. For SIMPLE shared values (counters, toggles, page
+ * title, session info, etc.) prefer `State` from `./state` — fewer concepts
+ * and no Proxy overhead.
+ *
  * Core concepts:
  * - createState: Proxy-based deep reactive state
  * - track/trigger/clear: publish-subscribe dependency tracking
@@ -1252,8 +2347,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 +2397,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;
@@ -1321,16 +2414,40 @@ declare const _stateKeys: unique symbol;
 declare const _storeState: unique symbol;
 declare const _storeDefScheduler: unique symbol;
 declare const _storeProxy: unique symbol;
+declare const _computedKeys: unique symbol;
+/**
+ * Declare a derived (computed) store property.
+ *
+ * Usage (inside a `defineStore` creator):
+ *
+ * ```ts
+ * defineStore("count", (store, { computed }) => ({
+ *   count: 0,
+ *   doubled: computed(["count"], () => store.count * 2),
+ *   increment() { store.count++ },
+ * }));
+ * ```
+ *
+ * `deps` lists the state keys the computed reads. Whenever any of those keys
+ * changes, the computed function re-runs and the new value flows out through
+ * the store like a regular state update — meaning views that
+ * `store.observe(this, ["doubled"])` re-render automatically.
+ *
+ * The returned value is typed as `T`, so the store body still type-checks as
+ * `{ doubled: number; ... }`. Writes to a computed key are ignored at runtime.
+ */
+declare function computed<T>(deps: readonly string[], fn: () => T): T;
 declare abstract class BaseStore {
     [_storeName]: string;
     [_storeStatus]: StoreStatus;
     [_storeScheduler]: Scheduler;
     [_originState]: Record<string, unknown>;
     [_stateKeys]: string[];
-    [_storeState]: ProxyObject;
+    [_storeState]: Record<string, unknown>;
+    [_computedKeys]: Set<string>;
     [_storeDefScheduler]: () => Queue;
     private [_outerStore];
-    [_storeBoot](): ProxyObject;
+    [_storeBoot](): Record<string, unknown>;
     [_storeDestroy](): void;
     /**
      *
@@ -1339,11 +2456,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: {
@@ -1359,13 +2476,22 @@ interface NodeStoreMethods {
     observe: (key: string, callback: AnyFunc, immediate?: boolean) => () => void;
 }
 interface StoreMethods {
-    observe: (view: LarkView | undefined, keys: (string | ObservePayload)[] | (() => (string | ObservePayload)[]), defCallback?: (changedMap: Record<string, unknown>) => void) => () => void;
+    /**
+     * Subscribe a view to store changes.
+     *
+     * - `store.observe(view)` — observe every state key (D5 default).
+     * - `store.observe(view, ["k1", "k2"])` — observe specific keys only.
+     * - `store.observe(view, ["k1"], (changes) => ...)` — explicit callback.
+     * - `store.observe(undefined, ["k1"], cb)` — inner observe (no view binding).
+     */
+    observe: (view: LarkView | undefined, keys?: (string | ObservePayload)[] | (() => (string | ObservePayload)[]), defCallback?: (changedMap: Record<string, unknown>) => void) => () => void;
 }
 /** Detect platform from a component instance */
 declare const getPlatform: (comp: unknown) => Platform | undefined;
 declare const extendApis: {
     lazySet: typeof lazySet;
     shallowSet: typeof shallowSet;
+    computed: typeof computed;
 };
 /** Inner store type available inside defineStore creator */
 type InnerStore<S = Record<string, unknown>> = S & StoreMethods;
@@ -1384,7 +2510,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;
 }];
@@ -1442,8 +2568,16 @@ interface SerializedFrameTree {
     /** Root element ID */
     rootId: string;
 }
+declare const FrameVisualBridge: {
+    MSG_PING: string;
+    MSG_PONG: string;
+    MSG_REQUEST_TREE: string;
+    MSG_TREE: string;
+    MSG_TREE_DELTA: string;
+};
 /**
  * Serialize the entire Frame tree starting from root.
+ * Returns an empty snapshot if the app hasn't booted yet.
  */
 declare function serializeFrameTree(): SerializedFrameTree;
 /**
@@ -1456,7 +2590,7 @@ declare function serializeFrameTree(): SerializedFrameTree;
 declare function installFrameVisualizerBridge(): void;
 
 /**
- * @lark/framework Template Compiler
+ * @lark.js/mvc Template Compiler
  *
  *   convertArtSyntax()    ({{}} → <% %>)
  *   processViewEvents()      (@event prefix + param encoding)
@@ -1464,9 +2598,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,34 +2610,26 @@ 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.
  *
  * The output is an ES module that exports a function with the signature:
- *   (data, selfId, refData) => string
+ *   (data, viewId, 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 +2654,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 { type AnyFunc, CALL_BREAK_TIME, Cache, type CacheEntry, type CacheInterface, type CacheOptions, type ChangeEvent, type CompileOptions, CrossSite, type CrossSiteConfig, EVENT_METHOD_REGEXP, EventDelegator, EventEmitter, type EventEmitterInterface, type EventListenerEntry, Frame, type FrameBoundElement, type FrameInterface, type FrameInvokeEntry, type FrameStaticEvent, FrameVisualBridge, Framework, type FrameworkConfig, type FrameworkInterface, LARK_VIEW, type LarkUseStore, type Location, type LocationDiff, type MixinEventHandler, type NodeUseStore, type ObservePayload, type ParamDiff, type ParsedUri, Payload, type PayloadEntry, type PayloadInterface, type PendingCacheEntry, Platform, RouterEvents as ROUTER_EVENTS, type ReactUseStore, type RouteChangeEvent, type RouteChangedEvent, type RouteViewConfig, Router, type RouterInterface, SPLITTER, type SerializedFrameNode, type SerializedFrameTree, type SerializedViewInfo, Service, type ServiceCacheInfo, type ServiceEntry, type ServiceEvent, type ServiceInterface, type ServiceMetaEntry, type ServiceOptions, State, type StateInterface, type StoreConfig, type StoreMethods, TAG_NAME_REGEXP, Updater, type UpdaterInterface, type VDomOp, type VDomRef, VIEW_EVENT_METHOD_REGEXP, type VdomElement, View, type ViewEvent, type ViewEventSelectorEntry, type ViewGlobalEventEntry, type ViewInterface, type ViewLocationObserved, type ViewObserveLocation, type ViewResourceEntry, type ViewTemplate, type VoidFunc, applyIdUpdates, applyStyle, applyVdomOps, assign, cell, cloneData, cloneStore, compileTemplate, computed, createState, createVdomRef, defineStore, defineView, delStore, encodeHTML, encodeQ, encodeSafe, encodeURIExtra, ensureElementId, extractGlobalVars, config as frameworkConfig, funcWithTry, generateId, getAttribute, getById, getPlatform, getStore, getUseStore, hasOwnProperty, installFrameVisualizerBridge, invalidateViewClass, isPlainObject, isPrimitive, isPrimitiveOrFunc, isState, isStoreActive, keys, lazySet, mark$1 as mark, markBooted, markRouterBooted, multi, nextCounter, nodeInside, noop, now, observeCell, parseUri, registerViewClass, resetProjectsMap, safeguard, serializeFrameTree, setData, shallowSet, mark as storeMark, unmark as storeUnmark, syncCounter, toMap, toUri, translateData, unmark$1 as unmark, use, vdomGetCompareKey, vdomGetNode, vdomSetAttributes, vdomSetChildNodes, vdomSetNode, vdomSpecialDiff, vdomUnmountFrames };