@lark.js/mvc 0.0.1

package/dist/index.d.cts

@@ -0,0 +1,1471 @@
+/**
+ * Lark framework type definitions.
+ * All shared types are defined here to eliminate type cheats across modules.
+ */
+/** Generic function type for event handlers and callbacks.
+ *  Uses any[] to accept callbacks with specific parameter types
+ *  (TypeScript function parameters are contravariant).
+ */
+type AnyFunc = (...args: any[]) => unknown;
+/** A function that returns void. */
+type VoidFunc = (...args: any[]) => void;
+interface CacheEntry<T> {
+    /** Original key without prefix */
+    originalKey: string;
+    /** Cached value */
+    value: T | undefined;
+    /** Access frequency count */
+    frequency: number;
+    /** Last access timestamp */
+    lastTimestamp: number;
+}
+interface CacheOptions<T> {
+    /** Maximum cache size before eviction triggers (default: 20) */
+    maxSize?: number;
+    /** Buffer size for eviction (default: 5) */
+    bufferSize?: number;
+    /** Callback when entry is removed */
+    onRemove?: (key: string) => void;
+    /** Comparator for sorting entries */
+    sortComparator?: (a: CacheEntry<T>, b: CacheEntry<T>) => number;
+}
+interface EventListenerEntry {
+    /** Handler function */
+    handler: AnyFunc;
+    /** Whether currently executing (1 = executing, '' = done) */
+    executing: number | string;
+}
+interface ParsedUri {
+    /** Path portion (before ? or #) */
+    path: string;
+    /** Key-value params */
+    params: Record<string, string>;
+}
+interface Location {
+    /** Full href */
+    href: string;
+    /** Query string (before #) */
+    srcQuery: string;
+    /** Hash string (after #) */
+    srcHash: string;
+    /** Parsed query object */
+    query: ParsedUri;
+    /** Parsed hash object */
+    hash: ParsedUri;
+    /** Merged params from query and hash */
+    params: Record<string, string>;
+    /** Resolved view path */
+    view?: string;
+    /** Resolved path */
+    path?: string;
+    /** Get param by key with optional default */
+    get: (key: string, defaultValue?: string) => string;
+}
+interface ParamDiff {
+    from: string;
+    to: string;
+}
+interface LocationDiff {
+    /** Changed params (key -> {from, to}) */
+    params: Record<string, ParamDiff>;
+    /** Whether path changed */
+    path?: ParamDiff;
+    /** Whether view changed */
+    view?: ParamDiff;
+    /** Whether this is a first forced change */
+    force: boolean;
+    /** Whether anything changed */
+    changed: boolean;
+}
+interface VDomRef {
+    /** ID update list: [element, newId][] */
+    idUpdates: [Element, string][];
+    /** Views that need post-processing */
+    views: ViewInstance[];
+    /** DOM operation list: [opCode, parent, newChild?, oldChild?][] */
+    domOps: VDomOp[];
+    /** Whether anything changed */
+    hasChanged: number;
+}
+type VDomOp = [1, Element, Element] | [2, Element, Element] | [4, Element, Element, Element] | [8, Element, Element, Element];
+type FrameChildrenMap = Record<string, string>;
+type FrameReadyMap = Record<string, number>;
+interface FrameInvokeEntry {
+    /** Method name */
+    name: string;
+    /** Method arguments */
+    args: unknown[];
+    /** Internal key for dedup */
+    key: string;
+    /** Whether removed (args match) */
+    removed?: boolean;
+}
+/** Mixin event handler with internal merge marker and handler list */
+interface MixinEventHandler extends AnyFunc {
+    /** Merged handler list */ a?: AnyFunc[];
+    /** Mixin marker: 1 = this is a mixin function */ b?: number;
+}
+/** View event selector map entry: handler name list with selector presence tracking */
+interface ViewEventSelectorEntry {
+    /** Selector name list */
+    selectors: string[];
+    /** Index signature for checking if selector is already registered */
+    [selector: string]: unknown;
+}
+/** View class internal markers (SPLITTER key) */
+type ViewClassInternal = Record<string, AnyFunc[]>;
+interface ViewLocationObserved {
+    /** Whether observing location */
+    flag: number;
+    /** Keys to observe */
+    keys: string[];
+    /** Whether observing path */
+    observePath: boolean;
+}
+interface ViewResourceEntry {
+    /** The resource entity */
+    entity: unknown;
+    /** Whether to destroy when render() is called */
+    destroyOnRender: boolean;
+}
+type ViewResourceMap = Record<string, ViewResourceEntry>;
+type ViewEventSelectorMap = Record<string, ViewEventSelectorEntry>;
+interface ViewGlobalEventEntry {
+    /** Handler function */
+    handler: AnyFunc;
+    /** Bound handler wrapper (for removeEventListener) */
+    boundHandler?: AnyFunc;
+    /** DOM element (window/document) */
+    element: EventTarget;
+    /** Event name */
+    eventName: string;
+    /** Modifiers */
+    modifiers: Record<string, boolean>;
+}
+type ViewEventObjectMap = Record<string, number>;
+interface ViewInstance {
+    /** 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 */
+    tmpl?: AnyFunc | string;
+    /** Location observation config */
+    locationObserved: ViewLocationObserved;
+    /** Observed state keys */
+    observedStateKeys?: string[];
+    /** Resource map */
+    resources: ViewResourceMap;
+    /** Selector event map: eventType -> selector list */
+    eventSelectorMap: ViewEventSelectorMap;
+    /** Event object map: eventType -> bitmask */
+    eventObjectMap: ViewEventObjectMap;
+    /** Global event list */
+    globalEventList: ViewGlobalEventEntry[];
+    /** Assign method reference */
+    assignMethod?: AnyFunc;
+    /** Whether endUpdate has been called (1 = pending) */
+    endUpdatePending?: number;
+    /** Render method (wrapped) */
+    render: AnyFunc;
+    /** init method */
+    init: AnyFunc;
+    /** Wrapped render method */
+    $b?: AnyFunc;
+    /** endUpdate pending flag */
+    $e?: number;
+    on: (event: string, handler: AnyFunc) => ViewInstance;
+    off: (event: string, handler?: AnyFunc) => ViewInstance;
+    fire: (event: string, data?: Record<string, unknown>, remove?: boolean, lastToFirst?: boolean) => ViewInstance;
+    beginUpdate: (id?: string) => void;
+    endUpdate: (id?: string, inner?: boolean) => void;
+    wrapAsync: <Fn extends AnyFunc>(fn: Fn, context?: unknown) => (...args: Parameters<Fn>) => ReturnType<Fn> | undefined;
+    observeLocation: (params: string | string[] | Record<string, unknown>, observePath?: boolean) => void;
+    observeState: (keys: string | string[]) => void;
+    capture: (key: string, resource?: unknown, destroyOnRender?: boolean) => unknown;
+    release: (key: string, destroy?: boolean) => unknown;
+    leaveTip: (message: string, condition: () => boolean) => void;
+    assign: (options?: unknown) => boolean | undefined;
+}
+/** Minimal Frame interface needed by View */
+interface FrameLike {
+    id: string;
+    parentId: string | undefined;
+    unmountZone: (zoneId?: string, inner?: boolean) => void;
+    mountZone: (zoneId?: string, inner?: boolean) => void;
+    mountFrame: (frameId: string, viewPath: string, viewInitParams?: Record<string, unknown>) => FrameLike;
+    unmountFrame: (id?: string, inner?: boolean) => void;
+    view: ViewInstance | undefined;
+    children: () => string[];
+    invoke: (name: string, args?: unknown[]) => unknown;
+    invokeList: FrameInvokeEntry[];
+    on: (event: string, handler: AnyFunc) => FrameLike;
+    off: (event: string, handler?: AnyFunc) => FrameLike;
+    fire: (event: string, data?: Record<string, unknown>) => FrameLike;
+}
+/** Minimal Updater interface needed by View */
+interface UpdaterLike {
+    get: <T = unknown>(key?: string) => T;
+    set: (data: Record<string, unknown>, excludes?: Set<string>) => UpdaterLike;
+    digest: (data?: Record<string, unknown>, excludes?: Set<string>) => void;
+    /** Save a snapshot of current data for altered() detection */
+    snapshot: () => this;
+    /** Check if data has changed since last snapshot */
+    altered: () => boolean | undefined;
+    /** Ref data for template rendering */
+    refData: Record<string, unknown>;
+}
+interface ServiceOptions {
+    /** Request URL */
+    url: string;
+    /** Request params */
+    params?: Record<string, unknown>;
+    /** HTTP method */
+    method?: "GET" | "POST" | "PUT" | "DELETE";
+    /** Cache: true for default, number for TTL */
+    cache?: boolean | number;
+    /** POST data */
+    data?: unknown;
+}
+interface BagEntry {
+    /** Bag data */
+    data: Record<string, unknown>;
+}
+interface ServiceEntry {
+    /** Service ID */
+    id: string;
+    /** Service URL */
+    url: string;
+    /** Cache time in ms, 0 = no cache */
+    cacheTime: number;
+    /** Bag instance */
+    bag?: BagEntry;
+    /** Whether loading */
+    loading?: boolean;
+    /** Error info */
+    error?: Error;
+}
+/** Pending cache entry for deduplication (internal to Service) */
+interface PendingCacheEntry extends Array<unknown> {
+    /** Reference to the pending Bag entity */
+    e?: unknown;
+}
+interface ServiceMetaEntry {
+    /** Endpoint name */
+    name: string;
+    /** URL */
+    url: string;
+    /** Cache TTL in ms, 0 = no cache */
+    cache?: number;
+    /** Before-fetch hook */
+    before?: AnyFunc;
+    /** After-fetch hook */
+    after?: AnyFunc;
+    /** Clean keys on destroy */
+    cleans?: string;
+    /** Additional properties */
+    [key: string]: unknown;
+}
+/** Cache info attached to Bag entity */
+interface ServiceCacheInfo {
+    /** Endpoint name */
+    name: string;
+    /** After-fetch hook */
+    after?: AnyFunc | undefined;
+    /** Clean keys */
+    cleans?: string | undefined;
+    /** Cache key */
+    key: string;
+    /** Timestamp when cached */
+    time: number;
+}
+interface FrameworkConfig {
+    /** Root element ID */
+    rootId: string;
+    /** Default view path */
+    defaultView?: string;
+    /** Default path when no hash present */
+    defaultPath?: string;
+    /** Route mapping: path -> view */
+    routes?: Record<string, string | RouteViewConfig>;
+    /** Hashbang prefix */
+    hashbang?: string;
+    /** Error handler */
+    error?: (error: Error) => void;
+    /** Extensions to load */
+    exts?: string[];
+    /** Init module to load */
+    ini?: string;
+    /** Rewrite function for routes */
+    rewrite?: (path: string, params: Record<string, string>, routes: Record<string, string>) => string;
+    /** Unmatched view (404) */
+    unmatchedView?: string;
+    /** Module require function */
+    require?: (names: string[], params?: Record<string, unknown>) => Promise<unknown> | undefined;
+    /** Skip view rendered check */
+    skipViewRendered?: boolean;
+    /** Remold function for event processing */
+    remold?: (target: HTMLElement, type: string, event: Event) => boolean;
+    /** Dynamic config access */
+    [key: string]: unknown;
+}
+interface RouteViewConfig {
+    /** View path */
+    view: string;
+    /** Additional properties merged into location */
+    [key: string]: unknown;
+}
+/** Element with VDOM diff cached compare key */
+interface VdomElement extends Element {
+    /** Whether compare key is cached */
+    compareKeyCached?: number | undefined;
+    /** Cached compare key */
+    cachedCompareKey?: string | undefined;
+    /** Whether auto-generated ID */
+    autoId?: number;
+}
+/** Element with frame binding */
+interface FrameBoundElement extends HTMLElement {
+    /** Frame instance bound to this element */
+    frame?: FrameLike;
+    /** Whether frame is bound (1 = bound) */
+    frameBound?: number;
+    /** View rendered flag */
+    viewRendered?: number;
+    /** Range frame ID */
+    rangeFrameId?: string;
+    /** Range element guid */
+    rangeElementGuid?: number;
+}
+
+/**
+ * Lark framework utility functions.
+ */
+
+/** Check if value is a plain object (not null, not array, typeof object) */
+declare function isPlainObject(value: unknown): value is Record<string, unknown>;
+/** Check if value is an array */
+declare const isArray: (arg: any) => arg is any[];
+/** Check if value is primitive or function (not a complex object) */
+declare function isPrimitiveOrFunc(value: unknown): boolean;
+/** Check if value is primitive (not object, not function) */
+declare function isPrimitive(value: unknown): boolean;
+declare function generateId(prefix?: string): string;
+/** Sync local counter with global counter */
+declare function syncCounter(val: number): void;
+declare function noop(): void;
+/** Safe hasOwnProperty check */
+declare function has<T extends object>(owner: T | undefined | null, prop: PropertyKey): boolean;
+/** Get object keys (own enumerable) */
+declare function keys<T extends object>(obj: T): string[];
+/** Assign properties from sources to target (like Object.assign but safer) */
+declare function assign<T extends object>(target: T, ...sources: Partial<T>[]): T;
+/**
+ * Execute functions in try-catch, ignoring errors.
+ * Returns the result of the last successfully executed function.
+ */
+declare function funcWithTry(fns: AnyFunc | AnyFunc[], args: unknown[], context: unknown, configError: (e: unknown) => void): unknown;
+/**
+ * Set newData into oldData, tracking changed keys.
+ * Returns whether any value changed.
+ */
+declare function setData(newData: Record<string, unknown>, oldData: Record<string, unknown>, changedKeys: Record<string, number>, excludes: Set<string>): boolean;
+/**
+ * Translate data references: if a value starts with SPLITTER, replace it
+ * with the corresponding value from the data object.
+ */
+declare function translateData(data: object, value: unknown): unknown;
+/** Get element by ID, or return the element itself if already an element */
+declare function getById(id: string | Element | null): Element | null;
+/** Get attribute from element safely */
+declare function getAttribute(element: Element, attr: string): string;
+/** Ensure element has an ID, generating one if missing. Returns the ID. */
+declare function ensureElementId(element: HTMLElement): string;
+/**
+ * Check if node A is inside node B (or is the same node).
+ * Uses compareDocumentPosition for efficiency.
+ */
+declare function nodeInside(a: string | HTMLElement, b: string | HTMLElement): boolean;
+/**
+ * Parse URI string into path and params object.
+ * e.g. "/xxx/?a=b&c=d" => { path: "/xxx/", params: { a: "b", c: "d" } }
+ */
+declare function parseUri(uri: string): ParsedUri;
+/**
+ * Convert path and params to URI string.
+ * e.g. toUri("/xxx/", { a: "b", c: "d" }) => "/xxx/?a=b&c=d"
+ */
+declare function toUri(path: string, params: Record<string, unknown>, keepEmptyObject?: Record<string, number>): string;
+/**
+ * Convert array to map/hash object.
+ * For simple arrays, counts occurrences.
+ * For object arrays, uses specified key as map key.
+ */
+declare function toMap<T>(list: T[] | null | undefined, key?: keyof T): Record<string, T | number>;
+/** Get current timestamp */
+declare function now(): number;
+/** Constructable function type */
+type Constructable = new (...args: never[]) => unknown;
+/**
+ * Implement classical inheritance with prototype chain.
+ * This is the only place where we touch constructor internals -
+ * it's a low-level framework utility for View.extend.
+ */
+declare function classExtend<Proto extends object, Statics extends object>(ctor: Constructable, base: Constructable, props: Proto, statics: Statics): void;
+
+/** Internal splitter character (invisible, used as namespace separator) */
+declare const SPLITTER = "\u001E";
+declare const ROUTER_EVENTS: {
+    CHANGE: string;
+    CHANGED: string;
+    PAGE_UNLOAD: string;
+};
+/** Attribute name: lark-key (static key for skipping VDOM diff) */
+declare const TAG_KEY = "lark-key";
+/** Attribute name: lark-attr-key (static attribute key) */
+declare const TAG_ATTR_KEY = "lark-attr-key";
+/** Attribute name: l (view key for assign) */
+declare const TAG_VIEW_KEY = "lark-view-key";
+/** Attribute name: lark-view */
+declare const LARK_VIEW = "lark-view";
+/** View event method regex: e.g. "app\x1eclickHandler(click)" or "clickHandler()"
+ * Group 1: optional frame ID (before SPLITTER)
+ * Group 2: handler name
+ * Group 3: params string
+ */
+declare const EVT_METHOD_REG: RegExp;
+/** View event method name regex: e.g. "name<click,mousedown>" or "$selector<click>" */
+declare const VIEW_EVT_METHOD_REG: RegExp;
+/** Tag name regex for I_GetNode */
+declare const TAG_NAME_REGEX: RegExp;
+/** Async task break time (ms) */
+declare const CALL_BREAK_TIME = 48;
+/** Increment global counter and return new value */
+declare function nextCounter(): number;
+
+/**
+ * Dynamically inject CSS styles into the document head.
+ * Returns a cleanup function to remove the injected styles.
+ *
+ * @param styleIdOrPairs - Style ID string or array of [id, content] pairs
+ * @param css - CSS content string (only used when first arg is string)
+ * @returns Cleanup function to remove the styles
+ */
+declare function applyStyle(styleIdOrPairs: string | string[], css?: string): () => void;
+
+/**
+ * Mark/Unmark: signature-based lifecycle tracking for async callbacks.
+ *
+ * mark() returns a validity checker function. If the host is "unmarked"
+ * (e.g. view re-rendered), the checker returns false, preventing stale callbacks.
+ */
+/**
+ * Create a mark for tracking async callback validity.
+ * Returns a function that checks if the mark is still valid.
+ *
+ * @param host - Object to store mark state on (typically a view)
+ * @param key - Key to track (typically "render" or specific async operation)
+ * @returns Checker function that returns true if mark is still valid
+ */
+declare function mark$1(host: object, key: string): () => boolean;
+/**
+ * Clear all marks for a host object, invalidating all existing checkers.
+ * Called when a view re-renders or is destroyed.
+ *
+ * @param host - Object whose marks should be cleared
+ */
+declare function unmark$1(host: object): void;
+
+/**
+ * Safeguard: Proxy-based debug protection for data objects.
+ *
+ * In DEBUG mode, wraps data objects with Proxy to:
+ * 1. Warn when data is read from a different page than where it was set
+ * 2. Prevent direct mutation (forces use of State.set/digest)
+ * 3. Track access patterns for debugging
+ */
+/**
+ * Wrap data with a Proxy for debug-mode protection.
+ * Only active when window.__lark_debug is true and Proxy is available.
+ *
+ * @param data - Data to wrap
+ * @param getter - Optional callback when properties are read
+ * @param setter - Optional callback when properties are written
+ * @param isRoot - Whether this is the root data object
+ * @returns Proxied data or original data if debug mode is off
+ */
+declare function safeguard<T>(data: T, getter?: ((key: string) => void) | null, setter?: ((path: string, value: unknown) => void) | null, isRoot?: boolean): T;
+
+/**
+ * Cache class with LFU-style eviction.
+ * Keys are prefixed with SPLITTER for namespace isolation.
+ *
+ * @example
+ * const cache = new Cache({ maxSize: 20, bufferSize: 5 });
+ * cache.set('user', { name: 'Alice' });
+ * const user = cache.get('user');
+ * cache.has('user'); // true
+ * cache.del('user');
+ */
+declare class Cache<T = unknown> {
+    /** Cache entries array */
+    private entries;
+    /** Fast lookup: prefixed key -> entry */
+    private lookup;
+    /** Buffer size for eviction */
+    private readonly bufferSize;
+    /** Maximum cache size */
+    private readonly maxSize;
+    /** Total capacity (maxSize + bufferSize) */
+    private readonly capacity;
+    /** Callback when entry is removed */
+    private readonly onRemove?;
+    /** Sort comparator */
+    private readonly comparator;
+    constructor(options?: CacheOptions<T>);
+    /** Prefix a key with SPLITTER for namespace isolation */
+    private prefixKey;
+    /**
+     * Get a cached value by key.
+     * Updates frequency and timestamp for cache sorting.
+     */
+    get(key: string): T | undefined;
+    /**
+     * Iterate all cached values.
+     */
+    forEach(callback: (value: T | undefined) => void): void;
+    /**
+     * Set or update a cached value.
+     * If key already exists, updates value and increments frequency.
+     * If cache exceeds capacity, triggers eviction.
+     */
+    set(key: string, value: T): void;
+    /**
+     * Delete a cached entry.
+     */
+    del(key: string): void;
+    /**
+     * Check if a key exists in cache.
+     */
+    has(key: string): boolean;
+    /** Get current cache size */
+    get size(): number;
+    /** Clear all entries */
+    clear(): void;
+    /** Evict least-used entries from cache */
+    private evictEntries;
+}
+
+/**
+ * Multi-cast event emitter class.
+ *
+ * @example
+ * const emitter = new EventEmitter();
+ * emitter.on('change', (data) => console.log(data));
+ * emitter.fire('change', { key: 'value' });
+ */
+declare class EventEmitter {
+    /** Event listeners: prefixed key -> listener array */
+    private listeners;
+    /**
+     * Bind event listener.
+     */
+    on(event: string, handler: AnyFunc): this;
+    /**
+     * Unbind event listener.
+     * If handler is provided, removes only that handler.
+     * If no handler, removes all handlers for the event.
+     */
+    off(event: string, handler?: AnyFunc): this;
+    /**
+     * Fire event, execute all bound handlers.
+     * Supports executing state management: handlers removed during
+     * execution are safely handled.
+     *
+     * @param event - Event name
+     * @param data - Event data (type property added automatically)
+     * @param remove - Whether to remove all handlers after firing
+     * @param lastToFirst - Whether to execute handlers in reverse order
+     */
+    fire(event: string, data?: Record<string, unknown>, remove?: boolean, lastToFirst?: boolean): this;
+}
+
+/** Mark framework as booted (called from Framework.boot) */
+declare function markBooted(): void;
+/**
+ * Observable in-memory data object.
+ * Provides get/set/digest/diff/clean methods for cross-view data sharing.
+ */
+declare const State: {
+    get<T = unknown>(key?: string): T;
+    set(data: Record<string, unknown>, excludes?: Set<string>): typeof State;
+    digest(data?: Record<string, unknown>, excludes?: Set<string>): void;
+    diff(): Readonly<Record<string, number>>;
+    clean(keys: string): {
+        ctor: AnyFunc;
+    };
+    on(event: string, handler: AnyFunc): typeof State;
+    off(event: string, handler?: AnyFunc): typeof State;
+    fire(event: string, data?: Record<string, unknown>, remove?: boolean): typeof State;
+};
+
+/**
+ * Hash-based router with two-phase change confirmation.
+ *
+ * @example
+ * Router.to('/list', { page: 2 });
+ * const loc = Router.parse();
+ * const diff = Router.diff();
+ */
+declare const Router: {
+    /** Parse href into Location object */
+    parse(href?: string): Location;
+    /** Compute diff between current and previous location */
+    diff(): LocationDiff | undefined;
+    /** Navigate to new URL */
+    to(pathOrParams: string | Record<string, unknown>, params?: Record<string, unknown>, replace?: boolean, silent?: boolean): void;
+    /** Join path segments */
+    join(...paths: string[]): string;
+    /** Bind event listener */
+    on(event: string, handler: AnyFunc): typeof Router;
+    /** Unbind event listener */
+    off(event: string, handler?: AnyFunc): typeof Router;
+    /** Fire event */
+    fire(event: string, data?: Record<string, unknown>, remove?: boolean): typeof Router;
+    /** Internal: bind hashchange (called by Framework.boot) */
+    _bind(): void;
+    /** Internal: set framework config */
+    _setConfig(cfg: FrameworkConfig): void;
+    /** Internal: notify hash change (for programmatic trigger) */
+    notify?(e?: Event): void;
+};
+/** Mark framework as booted (called by Framework.boot) */
+declare function markRouterBooted(): void;
+
+/**
+ * Base View class.
+ * Views are created via View.extend() and mounted by Frame.
+ *
+ */
+declare class View {
+    /** View ID (same as owner frame ID) */
+    id: string;
+    /** Owner frame */
+    owner: FrameLike | number;
+    /** Updater instance */
+    updater: UpdaterLike;
+    /** Signature: > 0 means active, incremented on render, 0 = destroyed */
+    signature: number;
+    /** Whether rendered at least once */
+    rendered?: boolean;
+    /** Whether view has template */
+    tmpl?: AnyFunc | string;
+    /** Location observation config */
+    locationObserved: ViewLocationObserved;
+    /** Observed state keys */
+    observedStateKeys?: string[];
+    /** Resource map */
+    resources: ViewResourceMap;
+    /** Selector event map: eventType -> handler name list */
+    eventSelectorMap: ViewEventSelectorMap;
+    /** Event object map: eventType -> bitmask */
+    eventObjectMap: ViewEventObjectMap;
+    /** Global event list */
+    globalEventList: ViewGlobalEventEntry[];
+    /** Assign method reference */
+    assignMethod?: AnyFunc;
+    /** Whether endUpdate pending */
+    endUpdatePending?: number;
+    /** Internal event storage */
+    private _events;
+    /**
+     * Initialize view (called by Frame when mounting).
+     */
+    init(): void;
+    /**
+     * Render view template (called by Frame after init).
+     * Wrapped by View_WrapMethod to manage signature + resources.
+     *
+     * Default implementation calls updater.digest() which:
+     * 1. Executes the template function with current data
+     * 2. Runs VDOM diff against previous DOM
+     * 3. Applies DOM operations
+     * 4. Calls endUpdate to mount child frames
+     *
+     */
+    render(): void;
+    on(event: string, handler: AnyFunc): this;
+    off(event: string, handler?: AnyFunc): this;
+    fire(event: string, data?: Record<string, unknown>, remove?: boolean, lastToFirst?: boolean): this;
+    /**
+     * Notify view that HTML update is about to begin.
+     * Unmounts child frames in the update zone.
+     */
+    beginUpdate(id?: string): void;
+    /**
+     * Notify view that HTML update has ended.
+     * Mounts child frames in the update zone and runs deferred invokes.
+     */
+    endUpdate(id?: string, inner?: boolean): void;
+    /**
+     * Wrap an async callback to check view signature before executing.
+     * If the view has been re-rendered or destroyed, the callback is skipped.
+     */
+    wrapAsync<Fn extends AnyFunc>(fn: Fn, context?: unknown): (...args: Parameters<Fn>) => ReturnType<Fn> | undefined;
+    /**
+     * Observe location parameters or path changes.
+     * When observed keys change, render() is called automatically.
+     */
+    observeLocation(params: string | string[] | Record<string, unknown>, observePath?: boolean): void;
+    /**
+     * Observe State data keys for changes.
+     * When observed keys change via State.digest(), render() is called.
+     */
+    observeState(observedKeys: string | string[]): void;
+    /**
+     * Capture (register) a resource under a key.
+     * If a resource already exists at that key, it's destroyed first.
+     * When destroyOnRender=true, the resource is destroyed on next render call.
+     */
+    capture(key: string, resource?: unknown, destroyOnRender?: boolean): unknown;
+    /**
+     * Release a captured resource.
+     * If destroy=true, calls the resource's destroy() method.
+     */
+    release(key: string, destroy?: boolean): unknown;
+    /**
+     * Set up a leave confirmation for route changes and page unload.
+     */
+    leaveTip(message: string, condition: () => boolean): void;
+    /** Collected ctors from mixins */
+    static ctors?: AnyFunc[];
+    /**
+     * Extend View to create a new View subclass.
+     *
+     * Supports:
+     * - props.ctor: constructor-like init (called with initParams + {node, deep})
+     * - props.mixins: array of mixin objects
+     * - Event method patterns: `'name<click>'` etc.
+     */
+    static extend(props?: ThisType<ViewInstance> & Record<string, unknown>, statics?: Record<string, unknown>): typeof View;
+    /**
+     * Merge mixins into View prototype.
+     */
+    static merge(...mixins: Record<string, unknown>[]): typeof View;
+}
+
+/**
+ * Frame (View Frame) class for view lifecycle management.
+ * Each frame owns a view and manages child frames.
+ *
+ */
+declare class Frame extends EventEmitter implements FrameLike {
+    /** Frame ID (same as owner DOM element ID) */
+    readonly id: string;
+    /** Parent Frame ID */
+    private _parentId;
+    get parentId(): string | undefined;
+    /** Children map: id -> id */
+    childrenMap: FrameChildrenMap;
+    /** Children count */
+    childrenCount: number;
+    /** Ready count (children that have fired 'created') */
+    readyCount: number;
+    /** Ready map: id -> 1 */
+    readyMap: FrameReadyMap;
+    /** View instance */
+    viewInstance?: ViewInstance;
+    /** Get view instance (read-only) */
+    get view(): ViewInstance | undefined;
+    /** Invoke list for deferred method calls */
+    invokeList: FrameInvokeEntry[];
+    /** Signature for async operation tracking */
+    signature: number;
+    /** Whether view has altered */
+    hasAltered: number;
+    /** Whether view is destroyed */
+    destroyed: number;
+    /** View path (lark-view attribute value) */
+    viewPath?: string;
+    /** Original template before mount */
+    originalTemplate?: string;
+    /** Hold fire created flag */
+    holdFireCreated: number;
+    /** Children created flag */
+    childrenCreated: number;
+    /** Children alter flag */
+    childrenAlter: number;
+    constructor(id: string, parentId?: string);
+    /**
+     * Mount a view to this frame.
+     *
+     * Complete flow:
+     * 1. Parse viewPath, translate query params from parent
+     * 2. Unmount current view
+     * 3. Load View class (via require or provided ViewClass)
+     * 4. View_Prepare (scan event methods)
+     * 5. Create View instance
+     * 6. View_DelegateEvents (bind DOM events)
+     * 7. Call view.init()
+     * 8. If view has tmpl, call render via Updater
+     * 9. If no tmpl, call endUpdate directly
+     */
+    mountView(viewPath: string, viewInitParams?: Record<string, unknown>): void;
+    /**
+     * Internal: actually mount the view after class is loaded.
+     */
+    doMountView(ViewClass: typeof View, params: Record<string, string>, node: HTMLElement, sign: number): void;
+    /**
+     * Unmount current view.
+     */
+    unmountView(): void;
+    /**
+     * Mount a child frame.
+     */
+    mountFrame(frameId: string, viewPath: string, viewInitParams?: Record<string, unknown>): FrameLike;
+    /**
+     * Unmount a child frame.
+     */
+    unmountFrame(id?: string, _inner?: boolean): void;
+    /**
+     * Mount all views in a zone.
+     */
+    mountZone(zoneId?: string, _inner?: boolean): void;
+    /**
+     * Unmount all views in a zone.
+     */
+    unmountZone(zoneId?: string, _inner?: boolean): void;
+    /**
+     * Get all child frame IDs.
+     */
+    children(): string[];
+    /**
+     * Get parent frame at given level.
+     * @param level - How many levels up (default 1)
+     */
+    parent(level?: number): Frame | undefined;
+    /**
+     * Invoke a method on the view.
+     */
+    invoke(name: string, args?: unknown[]): unknown;
+    /** Get frame by ID */
+    static get(id: string): Frame | undefined;
+    /** Get all frames */
+    static getAll(): Map<string, Frame>;
+    /** Get or create root frame */
+    static root(rootId?: string): Frame;
+    /** Bind event listener (static) */
+    static on(event: string, handler: AnyFunc): typeof Frame;
+    /** Unbind event listener (static) */
+    static off(event: string, handler?: AnyFunc): typeof Frame;
+    /** Fire event (static) */
+    static fire(event: string, data?: Record<string, unknown>): void;
+}
+/**
+ * Register a View class for a given view path.
+ * Called after module loading completes.
+ */
+declare function registerViewClass(viewPath: string, ViewClass: typeof View): void;
+
+/**
+ * Unmount frames within a DOM node.
+ */
+declare function vdomUnmountFrames(frame: FrameLike, node: ChildNode): void;
+/**
+ * Parse HTML string into a DOM element.
+ * Handles special elements (table, SVG, MathML) with wrapper elements.
+ */
+declare function vdomGetNode(html: string, refNode: Element): Element;
+/**
+ * Get compare key for a DOM node (for keyed diff).
+ * Uses id, lark-key (static key), or lark-view path.
+ */
+declare function vdomGetCompareKey(node: ChildNode): string | undefined;
+/**
+ * Special diff for form elements (value, checked, selected).
+ */
+declare function vdomSpecialDiff(oldNode: ChildNode, newNode: ChildNode): number;
+/**
+ * Set attributes from new element onto old element, tracking changes in ref.
+ */
+declare function vdomSetAttributes(oldNode: Element, newNode: Element, ref: VDomRef, keepId?: boolean): void;
+/**
+ * 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;
+/**
+ * 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;
+/**
+ * Create an empty VDomRef for tracking diff operations.
+ */
+declare function createVdomRef(): VDomRef;
+/**
+ * Apply VDOM diff operations to the DOM.
+ */
+declare function applyVdomOps(ops: VDomOp[]): void;
+/**
+ * Apply ID updates from VDOM diff.
+ */
+declare function applyIdUpdates(updates: [Element, string][]): void;
+/** Encode value for safe HTML output */
+declare function encodeHTML(v: unknown): string;
+/** Safe string conversion */
+declare function encodeSafe(v: unknown): string;
+/** URI-encode a value with extra character encoding */
+declare function encodeURIExtra(v: unknown): string;
+/** Quote-encode a value for attribute use */
+declare function encodeQ(v: unknown): string;
+
+/**
+ * Updater class for view data binding.
+ * Manages view-local data with change detection and VDOM diff triggering.
+ *
+ */
+declare class Updater implements UpdaterLike {
+    /** View ID (same as owner frame ID) */
+    private viewId;
+    /** Current data object */
+    private data;
+    /** Ref data for template rendering */
+    refData: Record<string, unknown>;
+    /** Changed keys in current digest cycle */
+    private changedKeys;
+    /** Whether data has changed since last digest */
+    private hasChangedFlag;
+    /** Digesting queue: supports re-digest during digest */
+    private digestingQueue;
+    /** Snapshot JSON string for altered() detection */
+    private snapshotJson;
+    constructor(viewId: string);
+    /**
+     * Get data by key.
+     * Returns entire data object if key is omitted.
+     */
+    get<T = unknown>(key?: string): T;
+    /**
+     * Set data, tracking changed keys.
+     * Returns this for chaining.
+     */
+    set(data: Record<string, unknown>, excludes?: Set<string>): this;
+    /**
+     * Detect changes and trigger VDOM re-render.
+     *
+     * The core rendering pipeline:
+     * 1. Set data if provided
+     * 2. If changed, run VDOM diff (template → new DOM → diff against old DOM)
+     * 3. Apply DOM operations
+     * 4. Apply ID updates
+     * 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;
+    /**
+     * Core digest execution.
+     */
+    private runDigest;
+    /**
+     * Save a snapshot of current data for altered() detection.
+     */
+    snapshot(): this;
+    /**
+     * Check if data has changed since last snapshot.
+     */
+    altered(): boolean | undefined;
+    /**
+     * Translate data references (SPLITTER-prefixed values).
+     */
+    translate(data: unknown): unknown;
+    /**
+     * Parse expression with data context.
+     */
+    parse(expr: string): unknown;
+    /**
+     * Get changed keys (for external inspection).
+     */
+    getChangedKeys(): Readonly<Record<string, number>>;
+}
+
+/**
+ * Bag wraps API response data with convenient access methods.
+ */
+declare class Bag {
+    /** Bag data */
+    data: Record<string, unknown>;
+    /** Internal cache info */
+    cacheInfo?: ServiceCacheInfo;
+    constructor(data?: Record<string, unknown>);
+    /** Get a value from bag data */
+    get<T = unknown>(key: string): T;
+    /** Set a value in bag data */
+    set(keyOrData: string | Record<string, unknown> | ServiceMetaEntry, value?: unknown): this;
+}
+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;
+    };
+    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;
+    };
+    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;
+}
+/**
+ * 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.
+ *
+ */
+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;
+    /**
+     * Clean up range events for a destroyed view.
+     */
+    clearRangeEvents(viewId: string): void;
+    /**
+     * Set the frame getter function (called by Framework.boot).
+     */
+    setFrameGetter(getter: (id: string) => FrameLike | undefined): void;
+    /**
+     * Get next element GUID.
+     */
+    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: {
+    /**
+     * Get or set framework configuration.
+     */
+    config(cfg?: FrameworkConfig | string): FrameworkConfig | unknown;
+    /**
+     * Boot the framework.
+     */
+    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;
+    /**
+     * Convert array to hash map.
+     */
+    toMap: typeof toMap;
+    /**
+     * Execute function in try-catch.
+     */
+    toTry: typeof funcWithTry;
+    /**
+     * Convert path + params to URL string.
+     */
+    toUrl: typeof toUri;
+    /**
+     * Parse URI string into path and params.
+     */
+    parseUrl: typeof parseUri;
+    /**
+     * Mix properties from source to target.
+     */
+    mix: typeof assign;
+    /**
+     * Check if object has own property.
+     */
+    has: typeof has;
+    /**
+     * Get object keys.
+     */
+    keys: typeof keys;
+    /**
+     * Check if node A is inside node B.
+     */
+    inside: typeof nodeInside;
+    /**
+     * Get element by ID (shorthand for document.getElementById).
+     */
+    node: typeof getById;
+    /**
+     * Apply CSS style.
+     */
+    applyStyle: typeof applyStyle;
+    /**
+     * Generate globally unique ID.
+     */
+    guid: typeof generateId;
+    /**
+     * Proxy-based debug guard.
+     */
+    guard: typeof safeguard;
+    /**
+     * Cache class.
+     */
+    Cache: typeof Cache;
+    /**
+     * Ensure element has an ID.
+     */
+    nodeId(element: HTMLElement): string;
+    /**
+     * Base class with EventEmitter.
+     */
+    Base: typeof Base;
+    /** Router module */
+    Router: {
+        parse(href?: string): Location;
+        diff(): LocationDiff | undefined;
+        to(pathOrParams: string | Record<string, unknown>, params?: Record<string, unknown>, replace?: boolean, silent?: boolean): void;
+        join(...paths: string[]): string;
+        on(event: string, handler: AnyFunc): typeof Router;
+        off(event: string, handler?: AnyFunc): typeof Router;
+        fire(event: string, data?: Record<string, unknown>, remove?: boolean): typeof Router;
+        _bind(): void;
+        _setConfig(cfg: FrameworkConfig): void;
+        notify?(e?: Event): void;
+    };
+    /** State module */
+    State: {
+        get<T = unknown>(key?: string): T;
+        set(data: Record<string, unknown>, excludes?: Set<string>): typeof State;
+        digest(data?: Record<string, unknown>, excludes?: Set<string>): void;
+        diff(): Readonly<Record<string, number>>;
+        clean(keys: string): {
+            ctor: AnyFunc;
+        };
+        on(event: string, handler: AnyFunc): typeof State;
+        off(event: string, handler?: AnyFunc): typeof State;
+        fire(event: string, data?: Record<string, unknown>, remove?: boolean): typeof State;
+    };
+    /** View class */
+    View: typeof View;
+    /** Frame class */
+    Frame: typeof Frame;
+};
+
+/**
+ * @lark/framework Store
+ *
+ * Reactive state management with Proxy-based dependency tracking.
+ * Adapted for Lark / React / Node.js.
+ *
+ * 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
+ */
+
+/** Reactive proxy object — all string keys map to unknown values */
+type ProxyObject = Record<string, unknown>;
+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): ProxyObject;
+declare function lazySet(target: ProxyObject, data: Record<string, unknown>): void;
+/** Shallow set: only top-level properties are reactive */
+declare function shallowSet(target: ProxyObject, 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]: ProxyObject;
+    [_storeDefScheduler]: () => Queue;
+    private [_outerStore];
+    [_storeBoot](): ProxyObject;
+    [_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](): ProxyObject;
+    get status(): StoreStatus;
+    get storeName(): string;
+    get scheduler(): Scheduler;
+    [_storeProxy](toOut?: boolean): ProxyObject;
+}
+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;
+}
+/** 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: ProxyObject, cb: AnyFunc, immediate?: boolean): () => void;
+declare function multi<S = Record<string, unknown>>(useStore: LarkUseStore<S>): [LarkUseStore<S>, {
+    ctor: AnyFunc;
+}];
+
+/**
+ * @lark/framework Template Compiler
+ *
+ *   convertArtSyntax()    ({{}} → <% %>)
+ *   processLarkEvents()      (lark-event prefix + param encoding)
+ *   compileToFunction()  (<% %> → JS template function)
+ *   extractGlobalVars()   (AST-based global var analysis via @babel/parser)
+ *
+ * - All template operators: = (escape), ! (raw), @ (ref lookup), : (binding)
+ * - lark-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
+ * - View ID injection (\x1f → '+$viewId+')
+ * - Post-processing cleanup of empty concatenations
+ * - 0 configuration: auto-extract variables via AST analysis
+ *
+ * Template syntax:
+ *   {{=variable}}              → escaped output
+ *   {{: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
+ *   {{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}} / {{/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
+ *
+ * Internally it calls the compiled template function with the standard
+ * signature: ($$,$viewId,$$ref,$e,$n,$eu,$i,$eq)
+ *
+ * @param source - The raw HTML template content
+ * @param options - Compilation options
+ * @returns ES module source code exporting the compiled template function
+ */
+declare function compileTemplate(source: string, options?: CompileOptions): string;
+/**
+ * Extract global variable names from a template source using AST analysis.
+ *
+ * 1. Convert template commands (<% %> blocks) into a form parseable by an AST parser
+ * 2. Walk the AST to find all Identifier nodes
+ * 3. Track variable declarations (VariableDeclarator, FunctionDeclaration) as local vars
+ * 4. Track function parameters as local vars
+ * 5. Remaining identifiers that are not local and not in the exclusion list are "global" —
+ *    they must be passed in as part of the data context ($$)
+ *
+ * This replaces the old regex-based `extractVariables()` with proper scope analysis,
+ * eliminating false positives from local template variables and function parameters.
+ *
+ * @param source - The raw HTML template content (with {{ }} syntax)
+ * @returns Array of global variable names found in the template
+ */
+declare function extractGlobalVars(source: string): string[];
+
+export { type AnyFunc, Bag, type BagEntry, CALL_BREAK_TIME, Cache, type CacheEntry, type CacheOptions, type CompileOptions, type Constructable, EVT_METHOD_REG, EventDelegator, EventEmitter, type EventListenerEntry, Frame, type FrameBoundElement, type FrameChildrenMap, type FrameInvokeEntry, type FrameLike, type FrameReadyMap, Framework, type FrameworkConfig, LARK_VIEW, type LarkUseStore, type Location, type LocationDiff, type MixinEventHandler, type NodeUseStore, type ObservePayload, type ParamDiff, type ParsedUri, type PendingCacheEntry, Platform, ROUTER_EVENTS, type ReactUseStore, type RouteViewConfig, Router, SPLITTER, Service, type ServiceCacheInfo, type ServiceConstructor, type ServiceEntry, type ServiceMetaEntry, type ServiceOptions, State, type StoreConfig, type StoreMethods, TAG_ATTR_KEY, TAG_KEY, TAG_NAME_REGEX, TAG_VIEW_KEY, Updater, type UpdaterLike, type VDomOp, type VDomRef, VIEW_EVT_METHOD_REG, type VdomElement, View, type ViewClassInternal, type ViewEventObjectMap, type ViewEventSelectorEntry, type ViewEventSelectorMap, type ViewGlobalEventEntry, type ViewInstance, type ViewLocationObserved, type ViewResourceEntry, type ViewResourceMap, type VoidFunc, applyIdUpdates, applyStyle, applyVdomOps, assign, cell, classExtend, cloneData, cloneStore, compileTemplate, createState, createVdomRef, defineStore, delStore, encodeHTML, encodeQ, encodeSafe, encodeURIExtra, ensureElementId, extractGlobalVars, funcWithTry, generateId, getAttribute, getById, getPlatform, getStore, getUseStore, has, isArray, isPlainObject, isPrimitive, isPrimitiveOrFunc, isState, isStoreActive, keys, lazySet, mark$1 as mark, markBooted, markRouterBooted, multi, nextCounter, nodeInside, noop, now, observeCell, parseUri, registerViewClass, safeguard, setData, shallowSet, mark as storeMark, unmark as storeUnmark, syncCounter, toMap, toUri, translateData, unmark$1 as unmark, vdomGetCompareKey, vdomGetNode, vdomSetAttributes, vdomSetChildNodes, vdomSetNode, vdomSpecialDiff, vdomUnmountFrames };