@lark.js/mvc 0.0.15 → 0.0.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lark.js/mvc",
-  "version": "0.0.15",
+  "version": "0.0.17",
   "description": "@lark.js/mvc - TypeScript MVC framework",
   "keywords": [
     "framework",
@@ -97,8 +97,7 @@
     "build": "pnpm build:tsup",
     "build:rollup": "rollup -c rollup.config.mjs",
     "build:tsup": "tsup",
-    "clean": "rm -rf dist",
-    "format": "prettier -w ./ --experimental-cli",
+    "format": "oxfmt --write ./",
     "typecheck": "tsc -p tsconfig.build.json --noEmit",
     "test": "vitest run",
     "test:watch": "vitest",
@@ -111,9 +110,9 @@
   },
   "devDependencies": {
     "@rollup/plugin-commonjs": "^29.0.3",
-    "@rspack/core": "^2.0.8",
     "@rollup/plugin-node-resolve": "^16.0.3",
     "@rollup/plugin-typescript": "^12.3.0",
+    "@rspack/core": "^2.1.1",
     "@types/node": "^24.13.2",
     "@vitest/coverage-v8": "4.1.6",
     "rollup": "^4.62.2",

package/dist/apply-style.d.ts

@@ -1,9 +0,0 @@
-/**
- * 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
- */
-export declare function applyStyle(styleIdOrPairs: string | string[], css?: string): () => void;

package/dist/cache.d.ts

@@ -1,69 +0,0 @@
-import type { CacheInterface, CacheOptions } from "./types";
-/**
- * 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');
- */
-export declare class Cache<T = unknown> implements CacheInterface<T> {
-    /** Cache entries array */
-    private entries;
-    /** Fast lookup: prefixed key -> entry */
-    private lookup;
-    /** Buffer size for eviction */
-    private readonly bufferSize;
-    /** Maximum cache size */
-    private readonly maxSize;
-    /** Total capacity (maxSize + bufferSize) */
-    private readonly capacity;
-    /** Callback when entry is removed */
-    private readonly onRemove?;
-    /** Sort comparator */
-    private readonly comparator;
-    constructor(options?: CacheOptions<T>);
-    /** Prefix a key with SPLITTER for namespace isolation */
-    private prefixKey;
-    /**
-     * Get a cached value by key.
-     * Updates frequency and timestamp for cache sorting.
-     */
-    get(key: string): T | undefined;
-    /**
-     * Iterate all cached values.
-     */
-    forEach(callback: (value: T | undefined) => void): void;
-    /**
-     * Set or update a cached value.
-     * If key already exists, updates value and increments frequency.
-     * If cache exceeds capacity, triggers eviction.
-     */
-    set(key: string, value: T): void;
-    /**
-     * Delete a cached entry. Removes it immediately from both the lookup map
-     * and the entries array so the GC can reclaim the value without waiting
-     * for the next eviction sweep.
-     */
-    del(key: string): void;
-    /**
-     * Check if a key exists in cache.
-     */
-    has(key: string): boolean;
-    /** Get current cache size */
-    get size(): number;
-    /** Clear all entries */
-    clear(): void;
-    /**
-     * Evict the `bufferSize` worst entries from the cache.
-     *
-     * Uses single-pass partial selection (O(n·k)) instead of sorting the entire
-     * `entries` array (O(n log n)). For the typical `bufferSize = 5` this is
-     * effectively a linear scan with at most 5 in-bucket comparisons per
-     * iteration — and it avoids mutating the rest of `entries`.
-     */
-    private evictEntries;
-}

package/dist/common.d.ts

@@ -1,64 +0,0 @@
-/**
- * Lark framework constants.
- */
-/** Internal splitter character (U+001E Record Separator, invisible, used as namespace separator).
- * Uses String.fromCharCode to survive bundlers that strip control-char literals. */
-export declare const SPLITTER: string;
-export declare const RouterEvents: {
-    CHANGE: string;
-    CHANGED: string;
-    PAGE_UNLOAD: string;
-};
-/** Attribute name: v-lark */
-export declare const LARK_VIEW = "v-lark";
-/** View event method regex: e.g. "app\x1eclickHandler(click)" or "clickHandler()"
- * Group 1: optional frame ID (before SPLITTER)
- * Group 2: handler name
- * Group 3: params string
- */
-export declare const EVENT_METHOD_REGEXP: RegExp;
-/** View event method name regex: e.g. "name<click,mousedown>" or "$selector<click>" */
-export declare const VIEW_EVENT_METHOD_REGEXP: RegExp;
-/** URL query/hash trim regexp */
-export declare const URL_TRIM_HASH_REGEXP: RegExp;
-/** URL trim query regexp (before hash) */
-export declare const URL_TRIM_QUERY_REGEXP: RegExp;
-/** URL param key-value regexp */
-export declare const URL_PARAM_REGEXP: RegExp;
-/** URL params test regexp */
-export declare const IS_URL_PARAMS: RegExp;
-/** URL query/hash trim regexp for path extraction */
-export declare const URL_QUERY_HASH_REGEXP: RegExp;
-/** SVG namespace */
-export declare const SVG_NS = "http://www.w3.org/2000/svg";
-/** MathML namespace */
-export declare const MATH_NS = "http://www.w3.org/1998/Math/MathML";
-/** Tag name regexp for I_GetNode */
-export declare const TAG_NAME_REGEXP: RegExp;
-/** Async task break time (ms) */
-export declare const CALL_BREAK_TIME = 48;
-/** VDOM text node tag value (number 0, falsy, distinct from string tags) */
-export declare const V_TEXT_NODE = 0;
-/** Namespace map for SVG/MathML element creation in VDOM mode */
-export declare const VDOM_NS_MAP: Record<string, string>;
-/** Increment global counter and return new value */
-export declare function nextCounter(): number;
-/** Null-safe String conversion */
-export declare function strSafe(v: unknown): string;
-/** HTML entity encoding for safe output */
-export declare function encodeHTML(v: unknown): string;
-/** URI-encode with extra character encoding */
-export declare function encodeURIExtra(v: unknown): string;
-/** Quote-encode for attribute values */
-export declare function encodeQuote(v: unknown): string;
-/**
- * Template reference function for creating stable keys for objects.
- * Stores objects in refData with SPLITTER-prefixed keys.
- */
-export declare function refFn(ref: Record<string, unknown>, value: unknown, key: string): string;
-/**
- * Check if a string is a refData reference token: SPLITTER followed by
- * one or more ASCII decimal digits. Used by utils.ts translateData and
- * updater.ts translate.
- */
-export declare function isRefToken(s: string): boolean;

package/dist/compiler/compile-template.d.ts

@@ -1,16 +0,0 @@
-import type { CompileOptions } from "@/types";
-/**
- * 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, viewId, refData) => string
- *
- * Internally it calls the compiled template function with the standard
- * signature: ($data,$viewId,$refAlt,$encHtml,$strSafe,$encUri,$refFn,$encQuote)
- *
- * @param source - The raw HTML template content
- * @param options - Compilation options
- * @returns ES module source code exporting the compiled template function
- */
-export declare function compileTemplate(source: string, options?: CompileOptions): Promise<string>;

package/dist/compiler/compile-to-vdom-function.d.ts

@@ -1,13 +0,0 @@
-/**
- * Compile the internal `<% %>` syntax to a VDOM template function string.
- *
- * Uses htmlparser2 for robust HTML parsing:
- * 1. Extract `<% %>` blocks into a store, replace with `\x00N\x00` placeholders
- * 2. Parse the protected source with `parseDocument`
- * 3. Walk the DOM tree recursively, emitting `$c()` (vdomCreate) calls
- *
- * Output is an arrow function:
- *   `($data,$viewId,$refAlt,$n,$refFn,$encUri,$encQuote)=>{...}`
- * that returns the root VDomNode.
- */
-export declare function compileToVDomFunction(source: string, debug: boolean, file?: string): string;

package/dist/compiler/extract-global-vars.d.ts

@@ -1,17 +0,0 @@
-/**
- * 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
- */
-export declare function extractGlobalVars(source: string): Promise<string[]>;

package/dist/compiler/template-syntax.d.ts

@@ -1,61 +0,0 @@
-/**
- * @lark.js/mvc Template Compiler
- *
- *   convertArtSyntax()    ({{}} → <% %>)
- *   processViewEvents()      (@event prefix + param encoding)
- *   compileToFunction()  (<% %> → JS template function)
- *   extractGlobalVars()   (AST-based global var analysis via @babel/parser)
- *
- * - All template operators: = (escape), ! (raw), @ (ref lookup), : (binding)
- * - @event attribute processing with $splitter prefix + \x1e separator
- * - $strSafe (null-safe toString), $encHtml (HTML entity encode), $encUri (URI encode), $encQuote (quote encode), $refFn (ref lookup)
- * - Debug mode with line tracking ($dbgExpr/$dbgArt/$dbgLine) and try-catch error wrapper
- * - View ID injection (\x1f → '+$viewId+')
- * - Post-processing cleanup of empty concatenations
- * - 0 configuration: auto-extract variables via AST analysis
- *
- * 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
- *   {{forOf list as item}}      → loop
- *   {{forOf list as item idx}}  → loop with index
- *   {{forIn obj as val key}}   → object iteration
- *   {{for(let i=0;i<n;i++)}}  → generic for loop
- *   {{if condition}}           → conditional
- *   {{else if condition}}      → else-if
- *   {{else}}                   → else
- *   {{/if}} / {{/forOf}} / {{/forIn}} / {{/for}} → close blocks
- *   {{set a = b}}              → variable declaration
- */
-/** Protected comment store — used internally by protectComments */
-/**
- * Preserve HTML comments to prevent template syntax inside comments from being converted.
- */
-export declare function protectComments(source: string): {
-    protectedSource: string;
-    comments: string[];
-};
-/**
- * Restore previously protected HTML comments.
- */
-export declare function restoreComments(source: string, comments: string[]): string;
-/**
- * Process @event attributes.
- *
- * 1. Add \x1f (VIEW_ID_PLACEHOLDER, becomes $viewId at render time) prefix + \x1e separator
- * 2. Convert JS object literal params to URL query params
- *
- * @click="handlerName({key: 'value'})" → @click="\x1f\x1ehandlerName(key=value)"
- * @click="handlerName()"               → @click="\x1f\x1ehandlerName()"
- * @click="goHome"                      → unchanged (no parens = not an event handler)
- */
-export declare function processViewEvents(source: string): string;
-/**
- * Convert {{=}}/{{:}}/{{!}}/{{@}} and control flow syntax to internal <% %> syntax.
- *
- * In debug mode, adds \x11-delimited line tracking markers:
- *   <%'lineNo\x11code\x11'%> before forOf art expression
- */
-export declare function convertArtSyntax(source: string, debug: boolean): string;

package/dist/cross-site.d.ts

@@ -1,29 +0,0 @@
-/**
- * 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
- */
-import { View } from "./view";
-/**
- * Reset the projects map cache (useful when crossConfigs change at runtime).
- */
-export 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;
-export default CrossSite;

package/dist/dom.d.ts

@@ -1,45 +0,0 @@
-import type { DomRef, DomOp, FrameInterface } from "./types";
-/**
- * Unmount frames within a DOM node.
- */
-export declare function domUnmountFrames(frame: FrameInterface, node: ChildNode): void;
-/**
- * Parse HTML string into a DOM element.
- * Handles special elements (table, SVG, MathML) with wrapper elements.
- */
-export declare function domGetNode(html: string, refNode: Element): Element;
-/**
- * Get compare key for a DOM node (for keyed diff).
- * Uses id or v-lark path.
- */
-export declare function domGetCompareKey(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.
- */
-export declare function domSpecialDiff(oldNode: ChildNode, newNode: ChildNode): number;
-/**
- * Set attributes from new element onto old element, tracking changes in ref.
- */
-export declare function domSetAttributes(oldNode: Element, newNode: Element, ref: DomRef, keepId?: boolean): void;
-/**
- * Set child nodes from new parent onto old parent using keyed diff algorithm.
- */
-export declare function domSetChildNodes(oldParent: Element, newParent: Element, ref: DomRef, frame: FrameInterface, keys_?: ReadonlySet<string>): void;
-/**
- * Diff two DOM nodes and apply changes.
- */
-export declare function domSetNode(oldNode: ChildNode, newNode: ChildNode, oldParent: Element, ref: DomRef, frame: FrameInterface, keys_?: ReadonlySet<string>): void;
-/**
- * Create an empty DomRef for tracking diff operations.
- */
-export declare function createDomRef(): DomRef;
-/**
- * Apply DOM diff operations to the DOM.
- */
-export declare function applyDomOps(ops: DomOp[]): void;
-/**
- * Apply ID updates from DOM diff.
- */
-export declare function applyIdUpdates(updates: [Element, string][]): void;

package/dist/event-delegator.d.ts

@@ -1,28 +0,0 @@
-import type { FrameInterface } from "./types";
-/**
- * DOM event delegation system.
- * Delegates events to document body for performance.
- *
- */
-export 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) => FrameInterface | undefined): void;
-    /**
-     * Get next element GUID.
-     */
-    nextElementGuid(): number;
-};

package/dist/event-emitter.d.ts

@@ -1,38 +0,0 @@
-import type { AnyFunc, ChangeEvent, EventEmitterInterface, EventListenerEntry } from "./types";
-/**
- * Multi-cast event emitter class.
- *
- * @example
- * const emitter = new EventEmitter();
- * emitter.on('change', (data) => console.log(data));
- * emitter.fire('change', { key: 'value' });
- */
-export 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;
-}

package/dist/frame.d.ts

@@ -1,143 +0,0 @@
-import { EventEmitter } from "./event-emitter";
-import { View } from "./view";
-import type { AnyFunc, FrameInterface, FrameInvokeEntry, ViewInterface } from "./types";
-/**
- * Frame (View Frame) class for view lifecycle management.
- * Each frame owns a view and manages child frames.
- *
- */
-export declare class Frame extends EventEmitter implements FrameInterface {
-    /** Frame ID (same as owner DOM element ID) */
-    readonly id: string;
-    /** Parent Frame ID */
-    private _parentId;
-    get parentId(): string | undefined;
-    /** Children map: id -> id */
-    childrenMap: Record<string, string>;
-    /** Children count */
-    childrenCount: number;
-    /** Ready count (children that have fired 'created') */
-    readyCount: number;
-    /** Set of child frame IDs that have fired 'created' */
-    readyMap: Set<string>;
-    /** View instance */
-    viewInstance?: ViewInterface;
-    /** Get view instance (read-only) */
-    get view(): ViewInterface | undefined;
-    /** Invoke list for deferred method calls */
-    invokeList: FrameInvokeEntry[];
-    /** Signature for async operation tracking */
-    signature: number;
-    /** Whether view has altered */
-    hasAltered: number;
-    /** Whether view is destroyed */
-    destroyed: number;
-    /** View path (v-lark attribute value) */
-    viewPath?: string;
-    /** Original template before mount */
-    originalTemplate?: string;
-    /** Hold fire created flag */
-    holdFireCreated: number;
-    /** Children created flag */
-    childrenCreated: number;
-    /** Children alter flag */
-    childrenAlter: number;
-    constructor(id: string, parentId?: string);
-    /**
-     * Mount a view to this frame.
-     *
-     * Complete flow:
-     * 1. Parse viewPath, translate query params from parent
-     * 2. Unmount current view
-     * 3. Load View class (via require or provided ViewClass)
-     * 4. View_Prepare (scan event methods)
-     * 5. Create View instance
-     * 6. View_DelegateEvents (bind DOM events)
-     * 7. Call view.init()
-     * 8. If view has template, call render via Updater
-     * 9. If no template, call endUpdate directly
-     */
-    mountView(viewPath: string, viewInitParams?: Record<string, unknown>): void;
-    /**
-     * Internal: actually mount the view after class is loaded.
-     */
-    doMountView(ViewClass: typeof View, params: Record<string, unknown>, node: HTMLElement, sign: number): void;
-    /**
-     * Unmount current view.
-     */
-    unmountView(): void;
-    /**
-     * Mount a child frame.
-     */
-    mountFrame(frameId: string, viewPath: string, viewInitParams?: Record<string, unknown>): FrameInterface;
-    /**
-     * Unmount a child frame.
-     */
-    unmountFrame(id?: string): void;
-    /**
-     * Mount all views in a zone.
-     */
-    mountZone(zoneId?: string): void;
-    /**
-     * Unmount all views in a zone.
-     */
-    unmountZone(zoneId?: string): void;
-    /**
-     * Get all child frame IDs.
-     */
-    children(): string[];
-    /**
-     * Get parent frame at given level.
-     * @param level - How many levels up (default 1)
-     */
-    parent(level?: number): Frame | undefined;
-    /**
-     * Invoke a method on the view.
-     */
-    invoke(name: string, args?: unknown[]): unknown;
-    /**
-     * Type-safe variant of `invoke`.
-     *
-     * `invoke()` accepts any string and any args, which silently hides
-     * mismatched call sites when a method gets renamed. `invokeTyped` carries
-     * the view's method signature through TypeScript so the compiler catches
-     * those mistakes:
-     *
-     * ```ts
-     * type Home = View & { loadData(id: string): Promise<void> };
-     * frame.invokeTyped<Home, "loadData">("loadData", ["user-1"]);
-     * ```
-     *
-     * Behavior is identical to `invoke` at runtime — same defer / direct-call
-     * paths — so it's a drop-in safer overload.
-     */
-    invokeTyped<V extends Record<string, unknown>, K extends keyof V & string>(name: K, args: V[K] extends (...a: infer A) => unknown ? A : never[]): V[K] extends (...a: never[]) => infer R ? R | undefined : unknown;
-    /** Get frame by ID */
-    static get(id: string): Frame | undefined;
-    /** Get all frames */
-    static getAll(): Map<string, Frame>;
-    /**
-     * Returns the existing root frame, or `undefined` if none has been created.
-     * Pure getter — never creates a Frame, never touches the DOM.
-     *
-     * Use `Frame.createRoot(id)` to create the root explicitly during framework
-     * boot. For Micro-Frontend hosts that own multiple independent containers,
-     * use `new Frame(containerId)` directly so each MF mount has its own root.
-     */
-    static getRoot(): Frame | undefined;
-    /**
-     * Create (or return) the singleton root frame for this app.
-     *
-     * Idempotent: subsequent calls always return the original root regardless
-     * of `rootId` — so passing a different id later is silently ignored.
-     * `Framework.boot()` is the canonical caller; user code rarely needs this.
-     */
-    static createRoot(rootId?: string): Frame;
-    /** 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;
-}
-export { registerViewClass, invalidateViewClass, getViewClassRegistry, } from "./view-registry";

package/dist/framework.d.ts

@@ -1,9 +0,0 @@
-import type { FrameworkInterface } from "./types";
-/** Wait result: OK = rendered, TIMEOUT_OR_NOT_FOUND = not rendered */
-export declare const WAIT_OK = 1;
-export declare const WAIT_TIMEOUT_OR_NOT_FOUND = 0;
-/**
- * Main framework object.
- * Provides boot, config, and all global utility methods.
- */
-export declare const Framework: FrameworkInterface;

package/dist/hmr.d.ts

@@ -1,53 +0,0 @@
-/**
- * Minimal HMR context interface.
- * Compatible with Vite's `import.meta.hot` and webpack's `module.hot`.
- * Defined here to avoid depending on bundler-specific type packages.
- */
-export interface HotContext {
-    /** Accept a self-update. The callback receives the new module namespace. */
-    accept(cb?: (mod: {
-        default?: unknown;
-    } | undefined) => void): void;
-    /** Register a cleanup callback that runs before this module is replaced. */
-    dispose(cb: (data: unknown) => void): void;
-    /** Force a full page reload (fallback when HMR cannot handle the update). */
-    invalidate(): void;
-}
-/**
- * Find all currently mounted frames whose viewPath matches the given path,
- * and re-mount them.
- *
- * After a new View class is registered via `registerViewClass`, calling this
- * function triggers `frame.mountView()` on each matching frame. Since the new
- * class is already in the registry, `Frame.mountView` takes the synchronous
- * path (`getViewClass` returns the class immediately).
- *
- * @param viewPath - The view path to match (e.g. 'home', 'components/list')
- */
-export declare function reloadViews(viewPath: string): void;
-/**
- * Set up the HMR accept handler for a view module.
- *
- * When the module is updated:
- * 1. Extracts the new View class from the new module (default export or module itself)
- * 2. Registers the new class in the view registry
- * 3. Re-mounts all frames currently using this viewPath
- *
- * If the new module doesn't export a valid View class, falls back to
- * `hot.invalidate()` which triggers a full page reload.
- *
- * @param hot - The HMR context (import.meta.hot)
- * @param viewPath - The view path identifier (e.g. 'home')
- */
-export declare function acceptView(hot: HotContext, viewPath: string): void;
-/**
- * Set up the HMR dispose handler for a view module.
- *
- * When the module is about to be replaced, removes the old View class
- * from the registry so that subsequent `getViewClass` calls don't return
- * the stale class.
- *
- * @param hot - The HMR context (import.meta.hot)
- * @param viewPath - The view path identifier (e.g. 'home')
- */
-export declare function disposeView(hot: HotContext, viewPath: string): void;