@lark.js/mvc 0.0.4 → 0.0.6

package/dist/index.d.ts

@@ -1,3 +1,41 @@
+/**
+ * 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.
@@ -14,7 +52,7 @@ declare class View implements ViewInterface {
     /** Whether rendered at least once */
     rendered?: boolean;
     /** Whether view has template */
-    template?: (data: unknown, viewId: string, refData: unknown, ...rest: unknown[]) => string | string;
+    template?: ViewTemplate;
     /** Location observation config */
     locationObserved: ViewLocationObserved;
     /** Observed state keys */
@@ -27,6 +65,8 @@ declare class View implements ViewInterface {
     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.
@@ -55,6 +95,8 @@ declare class View implements ViewInterface {
     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.
@@ -150,40 +192,44 @@ declare class View implements ViewInterface {
      */
     static merge(this: typeof View, ...mixins: Record<string, unknown>[]): typeof View;
 }
-
 /**
- * Multi-cast event emitter class.
+ * Type-safe wrapper around `View.extend()`.
  *
- * @example
- * const emitter = new EventEmitter();
- * emitter.on('change', (data) => console.log(data));
- * emitter.fire('change', { key: 'value' });
+ * `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 class EventEmitter<T = unknown> implements EventEmitterInterface<T> {
-    /** Event listeners: prefixed key -> listener array */
-    listeners: Map<string, EventListenerEntry[]>;
-    /**
-     * Bind event listener.
-     */
-    on(event: string, handler: (this: T, e: ChangeEvent) => void): this;
-    /**
-     * Unbind event listener.
-     * If handler is provided, removes only that handler.
-     * If no handler, removes all handlers for the event.
-     */
-    off(event: string, handler?: AnyFunc): this;
-    /**
-     * Fire event, execute all bound handlers.
-     * Supports executing state management: handlers removed during
-     * execution are safely handled.
-     *
-     * @param event - Event name
-     * @param data - Event data (type property added automatically)
-     * @param remove - Whether to remove all handlers after firing
-     * @param lastToFirst - Whether to execute handlers in reverse order
-     */
-    fire(event: string, data?: Record<string, unknown>, remove?: boolean, lastToFirst?: boolean): this;
-}
+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.
@@ -202,8 +248,8 @@ declare class Frame extends EventEmitter implements FrameInterface {
     childrenCount: number;
     /** Ready count (children that have fired 'created') */
     readyCount: number;
-    /** Ready map: id -> 1 */
-    readyMap: Record<string, number>;
+    /** Set of child frame IDs that have fired 'created' */
+    readyMap: Set<string>;
     /** View instance */
     viewInstance?: ViewInterface;
     /** Get view instance (read-only) */
@@ -245,7 +291,7 @@ declare class Frame extends EventEmitter implements FrameInterface {
     /**
      * Internal: actually mount the view after class is loaded.
      */
-    doMountView(ViewClass: typeof View, params: Record<string, string>, node: HTMLElement, sign: number): void;
+    doMountView(ViewClass: typeof View, params: Record<string, unknown>, node: HTMLElement, sign: number): void;
     /**
      * Unmount current view.
      */
@@ -279,11 +325,52 @@ declare class Frame extends EventEmitter implements FrameInterface {
      * 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>;
-    /** Get or create root 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;
@@ -292,11 +379,6 @@ declare class Frame extends EventEmitter implements FrameInterface {
     /** Fire event (static) */
     static fire(event: string, data?: Record<string, unknown>): void;
 }
-/**
- * Register a View class for a given view path.
- * Called after module loading completes.
- */
-declare function registerViewClass(viewPath: string, ViewClass: typeof View): void;
 
 /**
  * Cache class with LFU-style eviction.
@@ -343,7 +425,9 @@ declare class Cache<T = unknown> implements CacheInterface<T> {
      */
     set(key: string, value: T): void;
     /**
-     * Delete a cached entry.
+     * 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;
     /**
@@ -354,7 +438,14 @@ declare class Cache<T = unknown> implements CacheInterface<T> {
     get size(): number;
     /** Clear all entries */
     clear(): void;
-    /** Evict least-used entries from cache */
+    /**
+     * 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;
 }
 
@@ -365,7 +456,9 @@ declare class Cache<T = unknown> implements CacheInterface<T> {
  * Lark is a lightweight MVC frontend framework that provides:
  * - View: base view class with extend/merge inheritance and mixin support
  * - Router: hash-based two-phase route confirmation
- * - State: cross-view observable global state management
+ * - State: simple cross-view observable singleton (recommended for simple cases)
+ * - Store: zustand-aligned state management with create/getState/setState/subscribe
+ *   (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
@@ -377,6 +470,8 @@ declare class Cache<T = unknown> implements CacheInterface<T> {
  *  (TypeScript function parameters are contravariant).
  */
 type AnyFunc = (...args: any[]) => unknown;
+/** A function that returns void. */
+type VoidFunc = (...args: any[]) => void;
 interface CacheEntry<T> {
     /** Original key without prefix */
     originalKey: string;
@@ -558,7 +653,13 @@ interface VDomRef {
     /** Whether anything changed */
     hasChanged: number;
 }
-type VDomOp = [1, Element, Element] | [2, Element, Element] | [4, Element, Element, Element] | [8, Element, Element, Element];
+/**
+ * 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;
@@ -583,6 +684,12 @@ interface ViewEventSelectorEntry {
     /** Index signature for checking if selector is already registered */
     [selector: string]: unknown;
 }
+/**
+ * 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;
@@ -609,6 +716,20 @@ interface ViewGlobalEventEntry {
     /** Modifiers */
     modifiers: Record<string, boolean>;
 }
+/**
+ * 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.
@@ -640,6 +761,23 @@ interface RouterInterface extends EventEmitterInterface<RouterInterface> {
     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 | Promise<boolean>): () => void;
     /** Internal: bind hashchange (called by Framework.boot) */
     _bind(): void;
     /** Internal: set framework config */
@@ -655,6 +793,30 @@ interface RouterInterface extends EventEmitterInterface<RouterInterface> {
      */
     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.
@@ -688,10 +850,10 @@ interface ViewInterface extends EventEmitterInterface<ViewInterface> {
     /** Whether rendered at least once */
     rendered?: boolean;
     /**
-     * View template supporting function or string template.
-     * Function template signature: `(data: unknown, viewId: string, refData: unknown, ...rest: unknown[]) => string`
+     * View template function. Receives data + viewId + refData and a set of
+     * encoder helpers wired in by the Updater, and returns the rendered HTML.
      */
-    template?: (data: unknown, viewId: string, refData: unknown, ...rest: unknown[]) => string | string;
+    template?: ViewTemplate;
     /**
      * Mixin object array for extending view functionality.
      * Framework merges properties and methods from mixins into view prototype.
@@ -817,6 +979,7 @@ interface ViewInterface extends EventEmitterInterface<ViewInterface> {
      * @param args Mixin object list
      */
     merge?(...args: ExtendThisType<ViewInterface>[]): ViewInterface;
+    navigate?: (path: string, params?: Record<string, unknown>) => void;
 }
 type ExtendThisType<T> = Record<string, unknown> & ThisType<T>;
 /**
@@ -936,7 +1099,7 @@ interface UpdaterInterface {
      * @param data Data object, e.g., `{ a: 1, b: 2 }`
      * @param excludes Set of keys to exclude from change tracking
      */
-    set: (data: Record<string, unknown>, excludes?: Set<string>) => UpdaterInterface;
+    set: (data: Record<string, unknown>, excludes?: ReadonlySet<string>) => UpdaterInterface;
     /**
      * Trigger page re-render.
      * After set, must explicitly call `digest()` to commit changes to page.
@@ -945,7 +1108,7 @@ interface UpdaterInterface {
      * @param excludes Set of keys to exclude from change tracking
      * @param callback Callback executed after render completes
      */
-    digest: (data?: Record<string, unknown>, excludes?: Set<string>, callback?: () => void) => void;
+    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.
@@ -1002,10 +1165,9 @@ interface ChangeEvent {
      */
     readonly type: string;
     /**
-     * Set object of changed data keys, value 1 indicates key has changed.
-     * TODO: Optimize to Set data structure.
+     * Set of changed data keys. Use `keys.has(name)` to check membership.
      */
-    readonly keys?: Readonly<Record<string, 1>>;
+    readonly keys?: ReadonlySet<string>;
 }
 /**
  * Event emitter interface providing on/off/fire methods for publish-subscribe pattern.
@@ -1038,6 +1200,10 @@ interface EventEmitterInterface<T = unknown> {
  * 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, or fine-grained subscriptions — use `create` instead.
  */
 interface StateInterface extends EventEmitterInterface<StateInterface> {
     /**
@@ -1051,7 +1217,7 @@ interface StateInterface extends EventEmitterInterface<StateInterface> {
      * @param data Data object, e.g., `{ a: 1, b: 2 }`
      * @param excludes Set of keys to exclude from change tracking
      */
-    set(data: Record<string, unknown>, excludes?: Set<string>): this;
+    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")]`.
@@ -1069,11 +1235,11 @@ interface StateInterface extends EventEmitterInterface<StateInterface> {
      * @param data Optional data object, if provided calls `set()` first to set data
      * @param excludes Set of keys to exclude from change tracking
      */
-    digest(data?: Record<string, unknown>, excludes?: Set<string>): void;
+    digest(data?: Record<string, unknown>, excludes?: ReadonlySet<string>): void;
     /**
-     * Triggered when state data changes.
+     * Get the set of keys changed in the most recent digest.
      */
-    diff: () => Readonly<Record<string, number>>;
+    diff: () => ReadonlySet<string>;
     onChanged?: (e?: ChangeEvent) => void;
 }
 interface ServiceOptions {
@@ -1155,6 +1321,103 @@ interface ServiceMetaEntry {
     /** Additional properties */
     [key: string]: unknown;
 }
+interface ServiceInternals {
+    metaList: Record<string, ServiceMetaEntry>;
+    payloadCache: CacheInterface<PayloadInterface>;
+    pendingCacheKeys: Record<string, PendingCacheEntry>;
+    syncFn: (payload: PayloadInterface, callback: () => void) => void;
+    staticEmitter: EventEmitterInterface;
+}
+interface ServiceInterface {
+    id: string;
+    destroyed: number;
+    busy: number;
+    taskQueue: AnyFunc[];
+    prevArgs: unknown[];
+    emitter: EventEmitterInterface;
+    internals: ServiceInternals;
+    /**
+     * Send all requests in parallel, execute done callback when all requests complete (success or failure).
+     * If endpoint specifies cache and cache is valid, uses cached data directly.
+     * @param metaList Endpoint name string, params object, or array of them
+     * @param done Callback when all requests complete, first param is error array, followed by each endpoint's Payload
+     */
+    all(metaList: string | Record<string, unknown> | (string | Record<string, unknown>)[], done: AnyFunc): ServiceInterface;
+    /**
+     * Execute callback after each request succeeds, callback may be called multiple times.
+     * @param metaList Endpoint name string, params object, or array of them
+     * @param done Callback
+     */
+    one(attrs: string | Record<string, unknown> | (string | Record<string, unknown>)[], done: AnyFunc): ServiceInterface;
+    /**
+     * Similar to all, but always skips cache and forces actual requests.
+     * @param metaList Endpoint name string, params object, or array of them
+     * @param done Callback
+     */
+    save(metaList: string | Record<string, unknown> | (string | Record<string, unknown>)[], done: AnyFunc): ServiceInterface;
+    /**
+     * Queue task for execution, executes next task after previous all/one/save task completes, similar to Promise chain.
+     * @param callback Callback invoked after task completes
+     */
+    enqueue(callback: AnyFunc): ServiceInterface;
+    /**
+     * Dequeue and execute next task in queue.
+     */
+    dequeue(...args: unknown[]): void;
+    /**
+     * Destroy current Service instance, cannot send new requests or invoke callbacks after destruction.
+     */
+    destroy(): void;
+    /**
+     * Add endpoint metadata, register one or more API endpoints.
+     * @param metaList Endpoint metadata array, or single metadata object
+     */
+    add(attrs: ServiceMetaEntry | ServiceMetaEntry[]): void;
+    /**
+     * Get metadata object.
+     * @param attrs Endpoint metadata object or name string
+     */
+    meta(attrs: string | Record<string, unknown>): ServiceMetaEntry;
+    /**
+     * Create Payload object from endpoint metadata.
+     * @param meta Endpoint metadata object or name string
+     */
+    create(meta: Record<string, unknown>): PayloadInterface;
+    /**
+     * Get or create Payload object from cache.
+     * @param meta Endpoint metadata object
+     * @param createNew Whether to create new Payload object; if false, prioritizes getting from cache
+     */
+    get(meta: Record<string, unknown>, createNew?: boolean): {
+        entity: PayloadInterface;
+        needsUpdate: boolean;
+    };
+    /**
+     * Get Payload object from cache, returns undefined if cache doesn't exist or has expired.
+     * @param meta Endpoint metadata object
+     */
+    cached(meta: Record<string, unknown>): PayloadInterface | undefined;
+    /**
+     * Clear cached data for specified endpoint.
+     * @param names Comma-separated endpoint name string or string array
+     */
+    clear(names: string | string[]): void;
+    /**
+     * Inherit to create new Service subclass, bind custom data sync function.
+     * @param sync Method to sync data, typically exchanges data with server
+     * @param cacheMax Maximum cache entries
+     * @param cacheBuffer Cache buffer size
+     */
+    extend(newSyncFn: (payload: PayloadInterface, callback: () => void) => void, newCacheMax?: number, newCacheBuffer?: number): ServiceInterface;
+    /**
+     * Triggered before endpoint sends request.
+     */
+    onBegin?: (e?: ServiceEvent) => void;
+    /**
+     * Triggered when endpoint request completes, whether success or failure.
+     */
+    onEnd?: (e?: ServiceEvent) => void;
+}
 /** Cache info attached to Payload entity */
 interface ServiceCacheInfo {
     /** Endpoint name */
@@ -1170,13 +1433,27 @@ interface ServiceCacheInfo {
 }
 interface FrameworkInterface {
     /**
-     * Get or update configuration.
-     * - When passing config object: merges config and returns merged config
-     * - When passing key name: returns config value for that key
-     * - When no arguments: returns complete config object
-     * @param cfg Config object or key name
+     * 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.
@@ -1205,9 +1482,9 @@ interface FrameworkInterface {
      * Example: `Framework.toUrl('/xxx/', {a:'b',c:'d'})` => `/xxx/?a=b&c=d`
      * @param path Path string
      * @param params Params object
-     * @param keepEmpty Set of keys to keep empty values
+     * @param keepEmpty Set of keys whose empty values should be preserved
      */
-    toUrl(path: string, params?: Record<string, unknown>, keepEmpty?: Record<string, number>): string;
+    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'}}`
@@ -1365,6 +1642,12 @@ interface FrameworkConfig {
      * This field is required, defaults to "root".
      */
     rootId: string;
+    /**
+     * Routing mode.
+     * - `"history"` (default): uses `history.pushState` / `popstate`, clean URLs like `/home`
+     * - `"hash"`: uses URL hash fragment with `#!` prefix, e.g. `#!/home`
+     */
+    routeMode?: "history" | "hash";
     /**
      * Default view path.
      * Default root view path to load when URL doesn't match any route.
@@ -1383,7 +1666,7 @@ interface FrameworkConfig {
      * Use rewrite config item for path rewriting logic.
      */
     routes?: Record<string, string | RouteViewConfig>;
-    /** Hashbang prefix */
+    /** Hashbang prefix (only used in hash mode) */
     hashbang?: string;
     /**
      * Error handler.
@@ -1408,11 +1691,29 @@ interface FrameworkConfig {
      */
     unmatchedView?: string;
     /**
-     * Module require function
+     * 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;
+    require?: (names: string[], params?: Record<string, unknown>) => Promise<unknown[]> | undefined;
     /** Skip view rendered check */
     skipViewRendered?: boolean;
+    /**
+     * 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;
 }
@@ -1422,6 +1723,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 */
@@ -1469,7 +1787,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) */
@@ -1483,11 +1801,7 @@ declare function funcWithTry(fns: AnyFunc | AnyFunc[], args: unknown[], context:
  * 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;
@@ -1503,13 +1817,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.
@@ -1518,18 +1835,11 @@ 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: {
+/** Internal splitter character (U+001E Record Separator, invisible, used as namespace separator).
+ * Uses String.fromCharCode to survive bundlers that strip control-char literals. */
+declare const SPLITTER: string;
+declare const RouterEvents: {
     CHANGE: string;
     CHANGED: string;
     PAGE_UNLOAD: string;
@@ -1564,25 +1874,29 @@ 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;
+declare function mark(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;
+declare function unmark(host: object): void;
 
 /**
  * Safeguard: Proxy-based debug protection for data objects.
@@ -1613,7 +1927,7 @@ declare function markBooted(): void;
 declare const State: StateInterface;
 
 /**
- * Hash-based router with two-phase change confirmation.
+ * Router with two-phase change confirmation (supports history and hash modes).
  *
  * @example
  * Router.to('/list', { page: 2 });
@@ -1623,6 +1937,58 @@ declare const State: StateInterface;
 declare const Router: RouterInterface;
 /** Mark framework as booted (called by Framework.boot) */
 declare function markRouterBooted(): void;
+/** Get current routing mode */
+declare function getRouteMode(): "history" | "hash";
+
+/**
+ * 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
+ */
+
+/**
+ * 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.
@@ -1640,6 +2006,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;
 /**
@@ -1649,11 +2017,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: FrameInterface, 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: FrameInterface, 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.
  */
@@ -1691,10 +2059,16 @@ declare class Updater implements UpdaterInterface {
     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.
@@ -1705,7 +2079,7 @@ declare class Updater implements UpdaterInterface {
      * 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.
      *
@@ -1717,31 +2091,44 @@ declare class Updater implements UpdaterInterface {
      * 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>;
 }
 
 /**
@@ -1898,10 +2285,20 @@ declare class Service {
     static fire(event: string, data?: Record<string, unknown>): void;
     /**
      * Create a new Service subclass with a custom sync function.
-     * Each subclass gets its own per-type state (metaList, cache, etc.)
-     * to ensure isolation between different Service types.
+     *
+     * 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.
      */
-    static extend(newSyncFn: (payload: Payload, callback: () => void) => void, newCacheMax?: number, newCacheBuffer?: number): typeof Service;
+    static extend(this: typeof Service, newSyncFn: (payload: Payload, callback: () => void) => void, newCacheMax?: number, newCacheBuffer?: number): typeof Service;
 }
 
 /**
@@ -1939,152 +2336,100 @@ declare const EventDelegator: {
 declare const Framework: FrameworkInterface;
 
 /**
- * @lark/framework Store
+ * Sync view state with URL query parameters.
  *
- * Reactive state management with Proxy-based dependency tracking.
- * Adapted for Lark / React / Node.js.
+ * @param view - The view instance to bind to (for auto location observation and lifecycle)
+ * @param initialState - Default values for each URL param key. Keys not present
+ *   in the URL will use these defaults. Keys present in the URL override defaults.
+ * @returns A tuple `[state, setState]`:
+ *   - `state`: current values read from the URL, merged with defaults
+ *   - `setState`: update URL params. Accepts a partial object or an updater function.
+ *     Only the specified keys are changed; other URL params are preserved.
  *
- * Core concepts:
- * - createState: Proxy-based deep reactive state
- * - track/trigger/clear: publish-subscribe dependency tracking
- * - defineStore: declarative store definition with platform adapters
- * - cell/observeCell: lightweight standalone reactive cells
- */
+ * @example
+ * ```ts
+ * export default View.extend({
+ *   template,
+ *   init() {
+ *     const [state, setState] = useUrlState(this, { page: "1", size: "20" });
+ *     this.updater.set({ page: state.page, size: state.size }).digest();
+ *     this.setState = setState;
+ *   },
+ *   assign() {
+ *     const [state] = useUrlState(this, { page: "1", size: "20" });
+ *     this.updater.set({ page: state.page, size: state.size });
+ *   },
+ *   "nextPage<click>"() {
+ *     this.setState((prev) => ({ page: String(Number(prev.page) + 1) }));
+ *   },
+ * });
+ * ```
+ */
+declare function useUrlState<S extends Record<string, string>>(view: ViewInterface, initialState?: S): [Readonly<S>, (patch: Partial<S> | ((prev: S) => Partial<S>)) => void];
 
-interface Task {
-    cb: AnyFunc;
-    params?: Record<string, unknown>;
-}
-interface SchedulerObject {
-    add: (tasks: Task[]) => void;
-    clear: () => void;
-    delete: (tasks: Task[]) => void;
-}
-type Scheduler = SchedulerObject | ((cb: AnyFunc, payload: unknown) => void);
-interface StateConfig {
-    belong?: string;
-    linkKeys?: string;
-    shallow?: boolean;
-}
-interface StoreConfig {
-    platform?: Platform;
-    scheduler?: Scheduler;
-}
-interface ObservePayload {
-    key: string;
-    alias?: string;
-    cb?: (changedMap: Record<string, unknown>) => void;
-    lazy?: boolean;
-    transform?: (val: unknown) => Record<string, unknown>;
-}
-declare enum StoreStatus {
-    BEFORE_CREATE = 0,
-    CREATED = 1,
-    ACTIVE = 2,
-    DESTROYED = 3
-}
-declare enum Platform {
-    Lark = "lark",
-    React = "react",
-    Node = "node"
-}
-declare const cloneData: <T>(data: T) => T;
-declare class Queue {
-    private pendingTasks;
-    private queue;
-    flushTasks(): void;
-    add(tasks: Task[]): void;
-    delete(tasks: Task[]): void;
-    clear(): void;
-}
-/** Check if value is a reactive state */
-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): 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: Record<string, unknown>, key: string, data: unknown): unknown;
-declare const _storeName: unique symbol;
-declare const _storeStatus: unique symbol;
-declare const _storeScheduler: unique symbol;
-declare const _storeCreate: unique symbol;
-declare const _storeBoot: unique symbol;
-declare const _storeDestroy: unique symbol;
-declare const _innerStore: unique symbol;
-declare const _outerStore: unique symbol;
-declare const _originState: unique symbol;
-declare const _stateKeys: unique symbol;
-declare const _storeState: unique symbol;
-declare const _storeDefScheduler: unique symbol;
-declare const _storeProxy: unique symbol;
-declare abstract class BaseStore {
-    [_storeName]: string;
-    [_storeStatus]: StoreStatus;
-    [_storeScheduler]: Scheduler;
-    [_originState]: Record<string, unknown>;
-    [_stateKeys]: string[];
-    [_storeState]: Record<string, unknown>;
-    [_storeDefScheduler]: () => Queue;
-    private [_outerStore];
-    [_storeBoot](): Record<string, unknown>;
-    [_storeDestroy](): void;
-    /**
-     *
-     * @param body - The object returned by the creator function
-     * @param excludeFns - Function keys to exclude from handlers (e.g. ['observe'])
-     */
-    [_storeCreate](body: Record<string, unknown>, excludeFns?: string[]): void;
-    constructor(name: string, config?: StoreConfig);
-    [_innerStore](): Record<string, unknown>;
-    get status(): StoreStatus;
-    get storeName(): string;
-    get scheduler(): Scheduler;
-    [_storeProxy](toOut?: boolean): Record<string, unknown>;
-}
-interface LarkView {
-    updater: {
-        set: (data: Record<string, unknown>) => unknown;
-        digest: (data?: Record<string, unknown>) => void;
-    };
-    on: (event: string, handler: AnyFunc) => unknown;
-}
-type LarkUseStore<S = Record<string, unknown>> = (view?: LarkView) => S & StoreMethods;
-type ReactUseStore<S = Record<string, unknown>, StateSlice = S> = (selector?: (store: S & StoreMethods) => StateSlice) => StateSlice;
-type NodeUseStore<S = Record<string, unknown>> = () => S & NodeStoreMethods;
-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;
+/**
+ * @lark.js/mvc Store
+ *
+ * Zustand-aligned state management for Lark MVC.
+ *
+ * Core API:
+ * - create(name, creator): define a store with (set, get) => initialState
+ * - store.getState(): read current state snapshot
+ * - store.setState(partial | updater): shallow-merge state and notify listeners
+ * - store.subscribe(listener): listen for state changes
+ * - store.destroy(): tear down the store
+ * - computed(deps, fn): derived state that auto-recomputes when deps change
+ * - bindStore(view, store, selector?): Lark View lifecycle binding
+ */
+type Listener<T> = (state: T, prevState: T) => void;
+interface StoreApi<T = Record<string, unknown>> {
+    getState(): T;
+    setState(partial: Partial<T> | ((prev: T) => Partial<T>)): void;
+    subscribe(listener: Listener<T>): () => void;
+    destroy(): void;
 }
-/** Detect platform from a component instance */
-declare const getPlatform: (comp: unknown) => Platform | undefined;
-declare const extendApis: {
-    lazySet: typeof lazySet;
-    shallowSet: typeof shallowSet;
-};
-/** Inner store type available inside defineStore creator */
-type InnerStore<S = Record<string, unknown>> = S & StoreMethods;
-declare function defineStore<S = Record<string, unknown>>(name: string, creator: (store: InnerStore<S>, apis: typeof extendApis) => S, config?: StoreConfig & {
-    platform: Platform.Lark;
-}): LarkUseStore<S>;
-declare function defineStore<S = Record<string, unknown>>(name: string, creator: (store: InnerStore<S>, apis: typeof extendApis) => S, config?: StoreConfig & {
-    platform: Platform.React;
-}): ReactUseStore<S>;
-declare function defineStore<S = Record<string, unknown>>(name: string, creator: (store: InnerStore<S>, apis: typeof extendApis) => S, config?: StoreConfig & {
-    platform: Platform.Node;
-}): NodeUseStore<S>;
-declare function getStore(name: string): BaseStore | undefined;
-declare function delStore(name: string): void;
-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: Record<string, unknown>, cb: AnyFunc, immediate?: boolean): () => void;
-declare function multi<S = Record<string, unknown>>(useStore: LarkUseStore<S>): [LarkUseStore<S>, {
-    make: AnyFunc;
-}];
+type StateCreator<T> = (set: (partial: Partial<T> | ((prev: T) => Partial<T>)) => void, get: () => T) => T;
+/**
+ * Declare a derived (computed) store property.
+ *
+ * Usage inside a `create` creator:
+ * ```ts
+ * const store = create("counter", (set, get) => ({
+ *   count: 0,
+ *   doubled: computed(["count"], () => get().count * 2),
+ * }));
+ * ```
+ *
+ * `deps` lists the state keys the computed reads. Whenever any dep changes
+ * via `setState`, the computed re-evaluates before listeners are notified.
+ * Writes to a computed key via `setState` are silently ignored.
+ */
+declare function computed<T>(deps: readonly string[], fn: () => T): T;
+declare function create<T>(name: string, creator: StateCreator<T>): StoreApi<T>;
+/**
+ * Bind a store to a Lark View. Subscribes to state changes and auto-unsubscribes
+ * when the view is destroyed.
+ *
+ * @param view - Lark View instance (must have updater.set/digest and on("destroy"))
+ * @param store - Store created via `create()`
+ * @param selector - Optional function to pick a subset of state for the updater.
+ *   If omitted, only non-function state keys are forwarded.
+ * @returns unsubscribe function
+ *
+ * @example
+ * ```ts
+ * // Observe all state
+ * bindStore(this, useCountStore);
+ *
+ * // Observe with selector
+ * bindStore(this, useCountStore, (s) => ({ count: s.count }));
+ * ```
+ */
+declare function bindStore<T extends Record<string, unknown>>(view: unknown, store: StoreApi<T>, selector?: (state: T) => Record<string, unknown>): () => void;
+/**
+ * @deprecated Use `create()` instead. This is a temporary alias.
+ */
+declare const defineStore: typeof create;
 
 /** Serialized view info attached to a frame node */
 interface SerializedViewInfo {
@@ -2104,6 +2449,14 @@ interface SerializedViewInfo {
     };
     /** Whether view has a template function */
     hasTemplate: boolean;
+    /** Delegated event types (keys from $evtObjMap) */
+    eventMethodKeys: string[];
+    /** Captured resource keys */
+    resourceKeys: string[];
+    /** Whether view exposes an assign method (supports CrossSite reuse) */
+    hasAssign: boolean;
+    /** Updater refData snapshot (shallow copy of current data) */
+    updaterData: Record<string, unknown> | null;
 }
 /** A single node in the serialized frame tree */
 interface SerializedFrameNode {
@@ -2139,8 +2492,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;
 /**
@@ -2153,7 +2514,7 @@ declare function serializeFrameTree(): SerializedFrameTree;
 declare function installFrameVisualizerBridge(): void;
 
 /**
- * @lark/framework Template Compiler
+ * @lark.js/mvc Template Compiler
  *
  *   convertArtSyntax()    ({{}} → <% %>)
  *   processViewEvents()      (@event prefix + param encoding)
@@ -2189,7 +2550,7 @@ declare function installFrameVisualizerBridge(): void;
  * 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: ($data,$viewId,$refAlt,$encHtml,$strSafe,$encUri,$refFn,$encQuote)
@@ -2217,4 +2578,4 @@ declare function compileTemplate(source: string, options?: CompileOptions): stri
  */
 declare function extractGlobalVars(source: string): string[];
 
-export { CALL_BREAK_TIME, Cache, type CacheEntry, type CacheOptions, type CompileOptions, type Constructable, EVENT_METHOD_REGEXP, EventDelegator, EventEmitter, type EventListenerEntry, Frame, type FrameBoundElement, type FrameInterface, type FrameInvokeEntry, Framework, type FrameworkConfig, LARK_VIEW, type LarkUseStore, type Location, type LocationDiff, type MixinEventHandler, type NodeUseStore, type ObservePayload, type ParamDiff, type ParsedUri, Payload, type PayloadEntry, type PendingCacheEntry, Platform, ROUTER_EVENTS, type ReactUseStore, type RouteViewConfig, Router, SPLITTER, type SerializedFrameNode, type SerializedFrameTree, type SerializedViewInfo, Service, type ServiceCacheInfo, type ServiceEntry, type ServiceMetaEntry, type ServiceOptions, State, type StoreConfig, type StoreMethods, TAG_NAME_REGEXP, Updater, type UpdaterInterface, type VDomOp, type VDomRef, VIEW_EVENT_METHOD_REGEXP, type VdomElement, View, type ViewEventSelectorEntry, type ViewGlobalEventEntry, type ViewInterface, type ViewLocationObserved, type ViewResourceEntry, applyIdUpdates, applyStyle, applyVdomOps, assign, cell, classExtend, cloneData, cloneStore, compileTemplate, createState, createVdomRef, defineStore, delStore, encodeHTML, encodeQ, encodeSafe, encodeURIExtra, ensureElementId, extractGlobalVars, funcWithTry, generateId, getAttribute, getById, getPlatform, getStore, getUseStore, has, installFrameVisualizerBridge, isPlainObject, isPrimitive, isPrimitiveOrFunc, isState, isStoreActive, keys, lazySet, mark$1 as mark, markBooted, markRouterBooted, multi, nextCounter, nodeInside, noop, now, observeCell, parseUri, registerViewClass, safeguard, serializeFrameTree, setData, shallowSet, mark as storeMark, unmark as storeUnmark, syncCounter, toMap, toUri, translateData, unmark$1 as unmark, vdomGetCompareKey, vdomGetNode, vdomSetAttributes, vdomSetChildNodes, vdomSetNode, vdomSpecialDiff, vdomUnmountFrames };
+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 Location, type LocationDiff, type MixinEventHandler, type ParamDiff, type ParsedUri, Payload, type PayloadEntry, type PayloadInterface, type PendingCacheEntry, RouterEvents as ROUTER_EVENTS, type RouteChangeEvent, type RouteChangedEvent, type RouteViewConfig, Router, type RouterInterface, SPLITTER, type SerializedFrameNode, type SerializedFrameTree, type SerializedViewInfo, Service, type ServiceCacheInfo, type ServiceEntry, type ServiceEvent, type ServiceInterface, type ServiceMetaEntry, type ServiceOptions, State, type StateInterface, type StoreApi, TAG_NAME_REGEXP, Updater, type UpdaterInterface, 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, bindStore, compileTemplate, computed, create, createVdomRef, defineStore, defineView, encodeHTML, encodeQ, encodeSafe, encodeURIExtra, ensureElementId, extractGlobalVars, config as frameworkConfig, funcWithTry, generateId, getAttribute, getById, getRouteMode, hasOwnProperty, installFrameVisualizerBridge, invalidateViewClass, isPlainObject, isPrimitive, isPrimitiveOrFunc, keys, mark, markBooted, markRouterBooted, nextCounter, nodeInside, noop, now, parseUri, registerViewClass, resetProjectsMap, safeguard, serializeFrameTree, setData, syncCounter, toMap, toUri, translateData, unmark, use, useUrlState, vdomGetCompareKey, vdomGetNode, vdomSetAttributes, vdomSetChildNodes, vdomSetNode, vdomSpecialDiff, vdomUnmountFrames };