@lark.js/mvc 0.0.14 → 0.0.16

package/dist/index.cjs

@@ -21,32 +21,38 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   CALL_BREAK_TIME: () => CALL_BREAK_TIME,
-  Cache: () => Cache,
   CrossSite: () => cross_site_default,
   EVENT_METHOD_REGEXP: () => EVENT_METHOD_REGEXP,
   EventDelegator: () => EventDelegator,
-  EventEmitter: () => EventEmitter,
   Frame: () => Frame,
   Framework: () => Framework,
   LARK_VIEW: () => LARK_VIEW,
-  Payload: () => Payload,
   ROUTER_EVENTS: () => RouterEvents,
   Router: () => Router,
   SPLITTER: () => SPLITTER,
-  Service: () => Service,
   State: () => State,
   TAG_NAME_REGEXP: () => TAG_NAME_REGEXP,
-  Updater: () => Updater,
   VIEW_EVENT_METHOD_REGEXP: () => VIEW_EVENT_METHOD_REGEXP,
-  View: () => View,
-  applyStyle: () => applyStyle,
   bindStore: () => bindStore,
   computed: () => computed,
-  create: () => create,
+  createCache: () => createCache,
+  createEmitter: () => createEmitter,
+  createFrame: () => createFrame,
+  createPayload: () => createPayload,
+  createService: () => createService,
+  createStore: () => createStore,
+  createUpdater: () => createUpdater,
   createVDomRef: () => createVDomRef,
   defineView: () => defineView,
   frameworkConfig: () => config,
   getRouteMode: () => getRouteMode,
+  hotSwapByTemplate: () => hotSwapByTemplate,
+  hotSwapByView: () => hotSwapByView,
+  hotSwapFrames: () => hotSwapFrames,
+  hotSwapView: () => hotSwapView,
+  importsHtmlTemplate: () => importsHtmlTemplate,
+  injectTemplateHmrSnippet: () => injectTemplateHmrSnippet,
+  injectViewHmr: () => injectViewHmr,
   invalidateViewClass: () => invalidateViewClass,
   mark: () => mark,
   markBooted: () => markBooted,
@@ -57,6 +63,13 @@ __export(index_exports, {
   resetProjectsMap: () => resetProjectsMap,
   unmark: () => unmark,
   use: () => use,
+  useEffect: () => useEffect,
+  useEvent: () => useEvent,
+  useInterval: () => useInterval,
+  useResource: () => useResource,
+  useState: () => useState,
+  useStore: () => useStore,
+  useTimeout: () => useTimeout,
   useUrlState: () => useUrlState,
   vdomCreate: () => vdomCreate
 });
@@ -119,10 +132,7 @@ var URI_ENT_MAP = {
 };
 var URI_ENT_REGEXP = /[!')(*]/g;
 function encodeURIExtra(v) {
-  return encodeURIComponent(strSafe(v)).replace(
-    URI_ENT_REGEXP,
-    (m) => URI_ENT_MAP[m]
-  );
+  return encodeURIComponent(strSafe(v)).replace(URI_ENT_REGEXP, (m) => URI_ENT_MAP[m]);
 }
 var QUOTE_ENT_REGEXP = /['"\\]/g;
 function encodeQuote(v) {
@@ -147,19 +157,173 @@ function isRefToken(s) {
   return true;
 }
 
+// src/mark.ts
+var hostStore = /* @__PURE__ */ new WeakMap();
+function getOrCreate(host) {
+  let record = hostStore.get(host);
+  if (!record) {
+    record = { signs: /* @__PURE__ */ new Map(), deleted: false };
+    hostStore.set(host, record);
+  }
+  return record;
+}
+function mark(host, key) {
+  const record = getOrCreate(host);
+  if (record.deleted) {
+    return () => false;
+  }
+  const sign = (record.signs.get(key) ?? 0) + 1;
+  record.signs.set(key, sign);
+  return () => {
+    const current = hostStore.get(host);
+    return !!current && !current.deleted && current.signs.get(key) === sign;
+  };
+}
+function unmark(host) {
+  const record = hostStore.get(host);
+  if (record) {
+    record.deleted = true;
+    record.signs.clear();
+  } else {
+    hostStore.set(host, { signs: /* @__PURE__ */ new Map(), deleted: true });
+  }
+}
+
+// src/cache.ts
+function sortCacheEntries(a, b) {
+  return b.frequency - a.frequency || b.lastTimestamp - a.lastTimestamp;
+}
+function createCache(options = {}) {
+  let entries = [];
+  const lookup = /* @__PURE__ */ new Map();
+  const maxSize = options.maxSize ?? 20;
+  const bufferSize = options.bufferSize ?? 5;
+  const capacity = maxSize + bufferSize;
+  const onRemove = options.onRemove;
+  const comparator = options.sortComparator ?? sortCacheEntries;
+  function prefixKey(key) {
+    return SPLITTER + key;
+  }
+  function get(key) {
+    const prefixedKey = prefixKey(key);
+    const entry = lookup.get(prefixedKey);
+    if (!entry) return void 0;
+    entry.frequency++;
+    entry.lastTimestamp = nextCounter();
+    return entry.value;
+  }
+  function forEach(callback) {
+    for (const entry of entries) {
+      callback(entry.value);
+    }
+  }
+  function set(key, value) {
+    const prefixedKey = prefixKey(key);
+    const existing = lookup.get(prefixedKey);
+    if (existing) {
+      existing.value = value;
+      existing.frequency++;
+      existing.lastTimestamp = nextCounter();
+      return;
+    }
+    if (entries.length >= capacity) {
+      evictEntries();
+    }
+    const entry = {
+      originalKey: key,
+      value,
+      frequency: 1,
+      lastTimestamp: nextCounter()
+    };
+    entries.push(entry);
+    lookup.set(prefixedKey, entry);
+  }
+  function del(key) {
+    const prefixedKey = prefixKey(key);
+    const entry = lookup.get(prefixedKey);
+    if (!entry) return;
+    lookup.delete(prefixedKey);
+    const idx = entries.indexOf(entry);
+    if (idx !== -1) entries.splice(idx, 1);
+    if (onRemove) {
+      onRemove(key);
+    }
+  }
+  function has(key) {
+    return lookup.has(prefixKey(key));
+  }
+  function clear() {
+    if (onRemove) {
+      for (const entry of entries) {
+        onRemove(entry.originalKey);
+      }
+    }
+    entries = [];
+    lookup.clear();
+  }
+  function evictEntries() {
+    if (bufferSize <= 0 || entries.length === 0) return;
+    if (entries.length <= bufferSize) {
+      for (const e of entries) {
+        lookup.delete(prefixKey(e.originalKey));
+        if (onRemove) onRemove(e.originalKey);
+      }
+      entries = [];
+      return;
+    }
+    const worst = [];
+    for (const entry of entries) {
+      if (worst.length < bufferSize) {
+        let i = worst.length;
+        while (i > 0 && comparator(entry, worst[i - 1]) > 0) i--;
+        worst.splice(i, 0, entry);
+      } else if (comparator(entry, worst[bufferSize - 1]) > 0) {
+        worst.pop();
+        let i = worst.length;
+        while (i > 0 && comparator(entry, worst[i - 1]) > 0) i--;
+        worst.splice(i, 0, entry);
+      }
+    }
+    const evictSet = new Set(worst);
+    for (const e of worst) {
+      lookup.delete(prefixKey(e.originalKey));
+      if (onRemove) onRemove(e.originalKey);
+    }
+    entries = entries.filter((e) => !evictSet.has(e));
+  }
+  function getSize() {
+    return entries.length;
+  }
+  const api = {
+    get,
+    set,
+    del,
+    has,
+    clear,
+    forEach,
+    getSize
+  };
+  return api;
+}
+
 // src/utils.ts
 var CALL_BREAK_TIME2 = 9;
 var callQueue = [];
 var callScheduled = false;
-var schedulerYield = (() => {
+function getSchedulerYield() {
   try {
-    if (typeof globalThis?.scheduler?.yield === "function") {
-      return globalThis.scheduler.yield.bind(globalThis.scheduler);
+    const scheduler = Reflect.get(globalThis, "scheduler");
+    if (scheduler && typeof scheduler === "object" && typeof Reflect.get(scheduler, "yield") === "function") {
+      const yieldFn = Reflect.get(scheduler, "yield");
+      if (typeof yieldFn === "function") {
+        return yieldFn.bind(scheduler);
+      }
     }
   } catch {
   }
   return void 0;
-})();
+}
+var schedulerYield = getSchedulerYield();
 async function startCall() {
   callScheduled = false;
   const startTime = performance.now();
@@ -185,7 +349,9 @@ function scheduleNextChunk() {
   callScheduled = true;
 }
 function callFunction(fn, args) {
-  callQueue.push(() => fn(...args));
+  callQueue.push(() => {
+    fn(...args);
+  });
   if (!callScheduled) {
     scheduleNextChunk();
   }
@@ -202,7 +368,6 @@ function asRecord(value) {
   if (isRecord(value)) {
     return value;
   }
-  console.error("fallback to Object.fromEntries, even an empty object {}.");
   if (Array.isArray(value)) {
     return Object.fromEntries(value.entries());
   }
@@ -237,7 +402,7 @@ function assign(target, ...sources) {
     if (source) {
       for (const p in source) {
         if (hasOwnProperty(source, p)) {
-          target[p] = source[p];
+          Reflect.set(target, p, source[p]);
         }
       }
     }
@@ -276,16 +441,16 @@ function translateData(data, value) {
   if (isPrimitive(value)) {
     const prop = String(value);
     if (isRefToken(prop) && hasOwnProperty(data, prop)) {
-      return data[prop];
+      return Reflect.get(data, prop);
     }
     return value;
   }
   if (isPlainObject(value) || Array.isArray(value)) {
     for (const p in value) {
       if (hasOwnProperty(value, p)) {
-        const val = value[p];
+        const val = Reflect.get(value, p);
         const newVal = translateData(data, val);
-        value[p] = newVal;
+        Reflect.set(value, p, newVal);
       }
     }
     return value;
@@ -351,276 +516,32 @@ function toUri(path, params, keepEmpty) {
   }
   return path;
 }
-function toMap(list, key) {
-  const map = {};
-  if (!list) return map;
-  for (const item of list) {
-    const mapKey = key ? String(item[key]) : String(item);
-    map[mapKey] = key ? item : (map[mapKey] || 0) + 1;
-  }
-  return map;
-}
-
-// src/apply-style.ts
-var injectedStyleIds = /* @__PURE__ */ new Set();
-function applyStyle(styleIdOrPairs, css) {
-  if (Array.isArray(styleIdOrPairs)) {
-    if (styleIdOrPairs.length % 2 !== 0) {
-      throw new Error("Invalid array of [id, content] pairs");
-    }
-    const cleanupCallbacks = [];
-    for (let i = 0; i < styleIdOrPairs.length; i += 2) {
-      const styleId = styleIdOrPairs[i];
-      const styleContent = styleIdOrPairs[i + 1];
-      const cleanup = applyStyle(styleId, styleContent);
-      if (cleanup !== noop) {
-        cleanupCallbacks.push(cleanup);
-      }
-    }
-    return () => {
-      for (const cleanup of cleanupCallbacks) {
-        cleanup();
-      }
-    };
-  }
-  if (css && !injectedStyleIds.has(styleIdOrPairs)) {
-    injectedStyleIds.add(styleIdOrPairs);
-    const styleElement = document.createElement("style");
-    styleElement.setAttribute("from", "lark");
-    styleElement.id = styleIdOrPairs;
-    styleElement.textContent = css;
-    document.head.append(styleElement);
-    return () => {
-      injectedStyleIds.delete(styleIdOrPairs);
-      styleElement.remove();
-    };
-  }
-  return noop;
-}
-
-// src/mark.ts
-var hostStore = /* @__PURE__ */ new WeakMap();
-function getOrCreate(host) {
-  let record = hostStore.get(host);
-  if (!record) {
-    record = { signs: /* @__PURE__ */ new Map(), deleted: false };
-    hostStore.set(host, record);
-  }
-  return record;
-}
-function mark(host, key) {
-  const record = getOrCreate(host);
-  if (record.deleted) {
-    return () => false;
-  }
-  const sign = (record.signs.get(key) ?? 0) + 1;
-  record.signs.set(key, sign);
-  return () => {
-    const current = hostStore.get(host);
-    return !!current && !current.deleted && current.signs.get(key) === sign;
-  };
-}
-function unmark(host) {
-  const record = hostStore.get(host);
-  if (record) {
-    record.deleted = true;
-    record.signs.clear();
-  } else {
-    hostStore.set(host, { signs: /* @__PURE__ */ new Map(), deleted: true });
-  }
-}
-
-// src/cache.ts
-function sortCacheEntries(a, b) {
-  return b.frequency - a.frequency || b.lastTimestamp - a.lastTimestamp;
-}
-var Cache = class {
-  /** Cache entries array */
-  entries = [];
-  /** Fast lookup: prefixed key -> entry */
-  lookup = /* @__PURE__ */ new Map();
-  /** Buffer size for eviction */
-  bufferSize;
-  /** Maximum cache size */
-  maxSize;
-  /** Total capacity (maxSize + bufferSize) */
-  capacity;
-  /** Callback when entry is removed */
-  onRemove;
-  /** Sort comparator */
-  comparator;
-  constructor(options = {}) {
-    this.maxSize = options.maxSize ?? 20;
-    this.bufferSize = options.bufferSize ?? 5;
-    this.capacity = this.maxSize + this.bufferSize;
-    this.onRemove = options.onRemove;
-    this.comparator = options.sortComparator ?? sortCacheEntries;
-  }
-  /** Prefix a key with SPLITTER for namespace isolation */
-  prefixKey(key) {
-    return SPLITTER + key;
-  }
-  /**
-   * Get a cached value by key.
-   * Updates frequency and timestamp for cache sorting.
-   */
-  get(key) {
-    const prefixedKey = this.prefixKey(key);
-    const entry = this.lookup.get(prefixedKey);
-    if (!entry) return void 0;
-    entry.frequency++;
-    entry.lastTimestamp = nextCounter();
-    return entry.value;
-  }
-  /**
-   * Iterate all cached values.
-   */
-  forEach(callback) {
-    for (const entry of this.entries) {
-      callback(entry.value);
-    }
-  }
-  /**
-   * Set or update a cached value.
-   * If key already exists, updates value and increments frequency.
-   * If cache exceeds capacity, triggers eviction.
-   */
-  set(key, value) {
-    const prefixedKey = this.prefixKey(key);
-    const existing = this.lookup.get(prefixedKey);
-    if (existing) {
-      existing.value = value;
-      existing.frequency++;
-      existing.lastTimestamp = nextCounter();
-      return;
-    }
-    if (this.entries.length >= this.capacity) {
-      this.evictEntries();
-    }
-    const entry = {
-      originalKey: key,
-      value,
-      frequency: 1,
-      lastTimestamp: nextCounter()
-    };
-    this.entries.push(entry);
-    this.lookup.set(prefixedKey, 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) {
-    const prefixedKey = this.prefixKey(key);
-    const entry = this.lookup.get(prefixedKey);
-    if (!entry) return;
-    this.lookup.delete(prefixedKey);
-    const idx = this.entries.indexOf(entry);
-    if (idx !== -1) this.entries.splice(idx, 1);
-    if (this.onRemove) {
-      this.onRemove(key);
-    }
-  }
-  /**
-   * Check if a key exists in cache.
-   */
-  has(key) {
-    return this.lookup.has(this.prefixKey(key));
-  }
-  /** Get current cache size */
-  get size() {
-    return this.entries.length;
-  }
-  /** Clear all entries */
-  clear() {
-    if (this.onRemove) {
-      for (const entry of this.entries) {
-        this.onRemove(entry.originalKey);
-      }
-    }
-    this.entries = [];
-    this.lookup.clear();
-  }
-  /**
-   * 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`.
-   */
-  evictEntries() {
-    const entries = this.entries;
-    const k = this.bufferSize;
-    if (k <= 0 || entries.length === 0) return;
-    if (entries.length <= k) {
-      for (const e of entries) {
-        this.lookup.delete(this.prefixKey(e.originalKey));
-        if (this.onRemove) this.onRemove(e.originalKey);
-      }
-      this.entries = [];
-      return;
-    }
-    const cmp = this.comparator;
-    const worst = [];
-    for (const entry of entries) {
-      if (worst.length < k) {
-        let i = worst.length;
-        while (i > 0 && cmp(entry, worst[i - 1]) > 0) i--;
-        worst.splice(i, 0, entry);
-      } else if (cmp(entry, worst[k - 1]) > 0) {
-        worst.pop();
-        let i = worst.length;
-        while (i > 0 && cmp(entry, worst[i - 1]) > 0) i--;
-        worst.splice(i, 0, entry);
-      }
-    }
-    const evictSet = new Set(worst);
-    for (const e of worst) {
-      this.lookup.delete(this.prefixKey(e.originalKey));
-      if (this.onRemove) this.onRemove(e.originalKey);
-    }
-    this.entries = entries.filter((e) => !evictSet.has(e));
-  }
-};
 
 // src/event-emitter.ts
-var EventEmitter = class {
-  /** Event listeners: prefixed key -> listener array */
-  listeners = /* @__PURE__ */ new Map();
-  /** Number of `fire()` calls currently on the stack (re-entrancy depth). */
-  firingDepth = 0;
-  /** Keys whose listener list needs compaction after firing settles. */
-  pendingCompaction;
-  /**
-   * Bind event listener.
-   */
-  on(event, handler) {
+function createEmitter() {
+  const listeners = /* @__PURE__ */ new Map();
+  let firingDepth = 0;
+  let pendingCompaction;
+  function on(event, handler) {
     const key = SPLITTER + event;
-    let list = this.listeners.get(key);
+    let list = listeners.get(key);
     if (!list) {
       list = [];
-      this.listeners.set(key, list);
+      listeners.set(key, list);
     }
     list.push({ handler, executing: 0 });
-    return this;
+    return api;
   }
-  /**
-   * Unbind event listener.
-   * If handler is provided, removes only that handler.
-   * If no handler, removes all handlers for the event.
-   */
-  off(event, handler) {
+  function off(event, handler) {
     const key = SPLITTER + event;
     if (handler) {
-      const list = this.listeners.get(key);
-      if (!list) return this;
-      if (this.firingDepth > 0) {
+      const list = listeners.get(key);
+      if (!list) return api;
+      if (firingDepth > 0) {
         for (const listener of list) {
           if (listener.handler === handler) {
             listener.handler = noop;
-            (this.pendingCompaction ??= /* @__PURE__ */ new Set()).add(key);
+            (pendingCompaction ??= /* @__PURE__ */ new Set()).add(key);
             break;
           }
         }
@@ -631,35 +552,20 @@ var EventEmitter = class {
             break;
           }
         }
-        if (list.length === 0) this.listeners.delete(key);
+        if (list.length === 0) listeners.delete(key);
       }
     } else {
-      this.listeners.delete(key);
-      Reflect.deleteProperty(
-        this,
-        `on${event[0].toUpperCase() + event.slice(1)}`
-      );
+      listeners.delete(key);
+      Reflect.deleteProperty(internal, onMethodName(event));
     }
-    return this;
+    return api;
   }
-  /**
-   * 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, data, remove, lastToFirst) {
+  function fire(event, data, remove, lastToFirst) {
     const key = SPLITTER + event;
-    const list = this.listeners.get(key);
-    if (!data) {
-      data = {};
-    }
-    data["type"] = event;
-    this.firingDepth++;
+    const list = listeners.get(key);
+    const eventData = data ?? {};
+    eventData["type"] = event;
+    firingDepth++;
     try {
       if (list) {
         const len = list.length;
@@ -669,35 +575,45 @@ var EventEmitter = class {
           if (!listener) continue;
           if (listener.handler === noop) continue;
           listener.executing = 1;
-          funcWithTry([listener.handler], [data], this, noop);
+          funcWithTry([listener.handler], [eventData], null, noop);
           listener.executing = "";
         }
       }
-      const onMethodName = `on${event[0].toUpperCase() + event.slice(1)}`;
-      const onMethod = this[onMethodName];
+      const onMethod = internal[onMethodName(event)];
       if (typeof onMethod === "function") {
-        funcWithTry([onMethod], [data], this, noop);
+        funcWithTry([onMethod], [eventData], null, noop);
       }
       if (remove) {
-        this.off(event);
+        off(event);
       }
     } finally {
-      this.firingDepth--;
-      if (this.firingDepth === 0 && this.pendingCompaction) {
-        for (const k of this.pendingCompaction) {
-          const l = this.listeners.get(k);
+      firingDepth--;
+      if (firingDepth === 0 && pendingCompaction) {
+        for (const k of pendingCompaction) {
+          const l = listeners.get(k);
           if (!l) continue;
           for (let i = l.length - 1; i >= 0; i--) {
             if (l[i].handler === noop) l.splice(i, 1);
           }
-          if (l.length === 0) this.listeners.delete(k);
+          if (l.length === 0) listeners.delete(k);
         }
-        this.pendingCompaction = void 0;
+        pendingCompaction = void 0;
       }
     }
-    return this;
+    return api;
   }
-};
+  function onMethodName(event) {
+    return "on" + event[0].toUpperCase() + event.slice(1);
+  }
+  const internal = {
+    on,
+    off,
+    fire,
+    listeners
+  };
+  const api = internal;
+  return api;
+}
 
 // src/state.ts
 var appData = {};
@@ -705,10 +621,11 @@ var keyRefCounts = {};
 var changedKeys = /* @__PURE__ */ new Set();
 var stashedChangedKeys = EMPTY_STRING_SET;
 var dataIsChanged = false;
-var emitter = new EventEmitter();
+var emitter = createEmitter();
 var booted = false;
 function markBooted() {
   booted = true;
+  void booted;
 }
 function setupKeysRef(keys2) {
   const keyList = keys2.split(",");
@@ -769,17 +686,15 @@ var State = {
     return stashedChangedKeys;
   },
   /**
-   * Create mixin to clean up state keys on view destroy.
-   * Must be used in view.mixins array.
+   * Create a cleanup function for state keys on view destroy.
+   * Call inside setup: `State.clean("keys")(ctx)` or `useEvent("destroy", State.clean("keys"))`
    */
   clean(keys2) {
-    return {
-      make: function() {
-        const keyList = setupKeysRef(keys2);
-        this.on("destroy", () => {
-          teardownKeysRef(keyList);
-        });
-      }
+    return (ctx) => {
+      const keyList = setupKeysRef(keys2);
+      ctx.on("destroy", () => {
+        teardownKeysRef(keyList);
+      });
     };
   },
   /**
@@ -807,9 +722,9 @@ var State = {
 };
 
 // src/router.ts
-var emitter2 = new EventEmitter();
-var hrefCache = new Cache();
-var changedCache = new Cache();
+var emitter2 = createEmitter();
+var hrefCache = createCache();
+var changedCache = createCache();
 var lastLocation = createEmptyLocation();
 var lastChanged;
 var silent = 0;
@@ -853,11 +768,7 @@ function attachViewAndPath(loc) {
       path = cachedDefaultPath;
     }
     if (cachedRewrite) {
-      path = cachedRewrite(
-        path,
-        loc["params"],
-        cachedRoutes
-      );
+      path = cachedRewrite(path, loc["params"], cachedRoutes);
     }
     const viewEntry = cachedRoutes[path] || cachedUnmatchedView || cachedDefaultView;
     loc["path"] = path;
@@ -1060,7 +971,7 @@ var Router = {
     updateUrl(tPath, tParams, lastLocation, replace, silentFlag, lQuery);
   },
   /**
-   * Register an async-friendly navigation guard. See `RouterInterface.beforeEach`.
+   * Register an async-friendly navigation guard. See `RouterApi.beforeEach`.
    */
   beforeEach(guard) {
     beforeEachGuards.push(guard);
@@ -1210,7 +1121,7 @@ var selectorEvents = {};
 var rangeEvents = {};
 var rangeFrames = {};
 var elementGuid = 0;
-var eventInfoCache = new Cache({
+var eventInfoCache = createCache({
   maxSize: 30,
   bufferSize: 10
 });
@@ -1263,7 +1174,7 @@ function findFrameInfo(current, eventType) {
       if (frame) {
         const view = frame.view;
         if (view) {
-          const selectorEntry = view.eventSelectorMap[eventType];
+          const selectorEntry = { selectors: [] };
           if (selectorEntry) {
             for (const selectorName of selectorEntry.selectors) {
               const entry = {
@@ -1281,7 +1192,7 @@ function findFrameInfo(current, eventType) {
               }
             }
           }
-          if (view.template && !backtrace) {
+          if (view.getTemplate() && !backtrace) {
             if (match && !match.id) {
               match.id = frameId;
             }
@@ -1333,8 +1244,9 @@ function domEventProcessor(domEvent) {
         const frame = frameId ? frameGetter?.(frameId) : void 0;
         const view = frame?.view;
         if (view) {
-          const eventName = handlerName + SPLITTER + eventType;
-          const fn = Reflect.get(view, eventName);
+          const eventKey = handlerName + "<" + eventType + ">";
+          const events = typeof view.getEvents === "function" ? view.getEvents() : void 0;
+          const fn = events?.[eventKey];
           if (fn) {
             const extendedEvent = domEvent;
             extendedEvent.eventTarget = target;
@@ -1413,80 +1325,18 @@ var EventDelegator = {
   }
 };
 
-// src/module-loader.ts
-var config = {
-  rootId: "root",
-  routeMode: "history",
-  hashbang: "#!",
-  error: (error) => {
-    throw error;
-  }
-};
-function use(names, callback) {
-  const nameList = typeof names === "string" ? [names] : names;
-  const loadPromise = (() => {
-    if (config.require) {
-      const result = config.require(nameList);
-      if (result && typeof result.then === "function") {
-        return result;
-      }
-      return Promise.resolve([]);
-    }
-    return Promise.all(
-      nameList.map((name) => {
-        const importPath = name.startsWith(".") || name.startsWith("/") ? name : `./${name}`;
-        return import(
-          /* @vite-ignore */
-          /* webpackIgnore: true */
-          importPath
-        ).then((mod) => {
-          return mod && (mod["__esModule"] || // For Webpack
-          typeof mod["default"] === "function") ? mod["default"] : mod;
-        }).catch((err) => {
-          const errorHandler = config.error;
-          if (errorHandler) {
-            errorHandler(err instanceof Error ? err : new Error(String(err)));
-          }
-          return void 0;
-        });
-      })
-    );
-  })();
-  if (callback) {
-    loadPromise.then((modules) => {
-      callback(...modules);
-    });
-  }
-  return loadPromise;
-}
-
-// src/frame-registry.ts
-var frameRegistry = /* @__PURE__ */ new Map();
-function getFrame(id) {
-  return frameRegistry.get(id);
-}
-function getAllFrames() {
-  return frameRegistry;
-}
-function registerFrame(id, frame) {
-  frameRegistry.set(id, frame);
-}
-function removeFrame(id) {
-  frameRegistry.delete(id);
-}
-
-// src/dom.ts
-var wrapMeta = {
-  option: [1, "<select multiple>"],
-  thead: [1, "<table>"],
-  col: [2, "<table><colgroup>"],
-  tr: [2, "<table><tbody>"],
-  td: [3, "<table><tbody><tr>"],
-  area: [1, "<map>"],
-  param: [1, "<object>"],
-  svg: [1, '<svg xmlns="' + SVG_NS + '">'],
-  math: [1, '<math xmlns="' + MATH_NS + '">'],
-  _: [0, ""]
+// src/dom.ts
+var wrapMeta = {
+  option: [1, "<select multiple>"],
+  thead: [1, "<table>"],
+  col: [2, "<table><colgroup>"],
+  tr: [2, "<table><tbody>"],
+  td: [3, "<table><tbody><tr>"],
+  area: [1, "<map>"],
+  param: [1, "<object>"],
+  svg: [1, '<svg xmlns="' + SVG_NS + '">'],
+  math: [1, '<math xmlns="' + MATH_NS + '">'],
+  _: [0, ""]
 };
 wrapMeta["optgroup"] = wrapMeta["option"];
 wrapMeta["tbody"] = wrapMeta["tfoot"] = wrapMeta["colgroup"] = wrapMeta["caption"] = wrapMeta["thead"];
@@ -1749,7 +1599,7 @@ function vdomCreate(tag, props, children, specials) {
       html: String(props ?? "")
     };
   }
-  const propsObj = props || {};
+  const propsObj = typeof props === "object" && props !== null ? props : {};
   const specialsObj = specials || {};
   const unary = children === 1;
   let compareKey;
@@ -1820,12 +1670,7 @@ function vdomCreate(tag, props, children, specials) {
       const parsed = parseUri(value);
       isLarkView2 = parsed.path;
       if (!viewList) viewList = [];
-      viewList.push([
-        isLarkView2,
-        propsObj["lark-owner"],
-        value,
-        parsed.params
-      ]);
+      viewList.push([isLarkView2, propsObj["lark-owner"], value, parsed.params]);
       if (!compareKey) {
         compareKey = tag + SPLITTER + isLarkView2;
       }
@@ -1861,6 +1706,11 @@ function vdomCreateNode(vnode, owner, ref) {
   if (tag === V_TEXT_NODE) {
     return document.createTextNode(vnode.html);
   }
+  if (tag === SPLITTER) {
+    const template = document.createElement("template");
+    template.innerHTML = vnode.html;
+    return template.content.firstChild || document.createTextNode("");
+  }
   const sTag = typeof tag === "string" ? tag : tag.toString();
   const ns = VDOM_NS_MAP[sTag] || owner.namespaceURI;
   const el = document.createElementNS(ns, sTag);
@@ -1944,6 +1794,14 @@ function vdomSetNode(realNode, oldParent, lastVDom, newVDom, ref, frame, keys2,
     return;
   }
   if (lastTag === newTag) {
+    if (newTag === SPLITTER) {
+      if (lastVDom.html !== newVDom.html) {
+        ref.changed = 1;
+        domUnmountFrames(frame, realNode);
+        oldParent.replaceChild(vdomCreateNode(newVDom, oldParent, ref), realNode);
+      }
+      return;
+    }
     if (lastVDom.attrs === newVDom.attrs && lastVDom.html === newVDom.html) {
       if (newVDom.hasSpecials) {
         vdomSyncFormState(realNode, newVDom);
@@ -1952,12 +1810,7 @@ function vdomSetNode(realNode, oldParent, lastVDom, newVDom, ref, frame, keys2,
     }
     let attrChanged = 0;
     if (lastVDom.attrs !== newVDom.attrs || newVDom.hasSpecials) {
-      attrChanged = vdomSetAttributes(
-        realNode,
-        newVDom,
-        ref,
-        lastVDom
-      );
+      attrChanged = vdomSetAttributes(realNode, newVDom, ref, lastVDom);
       if (attrChanged) ref.changed = 1;
     }
     let updateChildren = true;
@@ -1971,16 +1824,7 @@ function vdomSetNode(realNode, oldParent, lastVDom, newVDom, ref, frame, keys2,
     }
     vdomSyncFormState(realNode, newVDom);
     if (updateChildren && !newVDom.selfClose) {
-      vdomSetChildNodes(
-        realNode,
-        lastVDom,
-        newVDom,
-        ref,
-        frame,
-        keys2,
-        rootView,
-        ready
-      );
+      vdomSetChildNodes(realNode, lastVDom, newVDom, ref, frame, keys2, rootView, ready);
     }
   } else {
     ref.changed = 1;
@@ -2050,17 +1894,7 @@ function vdomSetChildNodes(realNode, lastVDom, newVDom, ref, frame, keys2, view,
     const nc = newChildren[newHead];
     if (!isSameVDomNode(nc, oc)) break;
     if (nc.tag === SPLITTER || oc.tag === SPLITTER) break;
-    vdomSetNode(
-      oldDomNodes[headIdx],
-      realNode,
-      oc,
-      nc,
-      ref,
-      frame,
-      keys2,
-      view,
-      ready
-    );
+    vdomSetNode(oldDomNodes[headIdx], realNode, oc, nc, ref, frame, keys2, view, ready);
     usedOldDomNodes.add(oldDomNodes[headIdx]);
     headIdx++;
     newHead++;
@@ -2070,17 +1904,7 @@ function vdomSetChildNodes(realNode, lastVDom, newVDom, ref, frame, keys2, view,
     const nc = newChildren[newTail];
     if (!isSameVDomNode(nc, oc)) break;
     if (nc.tag === SPLITTER || oc.tag === SPLITTER) break;
-    vdomSetNode(
-      oldDomNodes[tailIdx],
-      realNode,
-      oc,
-      nc,
-      ref,
-      frame,
-      keys2,
-      view,
-      ready
-    );
+    vdomSetNode(oldDomNodes[tailIdx], realNode, oc, nc, ref, frame, keys2, view, ready);
     usedOldDomNodes.add(oldDomNodes[tailIdx]);
     tailIdx--;
     newTail--;
@@ -2203,113 +2027,88 @@ function createVDomRef(viewId) {
 }
 
 // src/updater.ts
-var Updater = class {
-  /** View ID (same as owner frame ID) */
-  viewId;
-  /** Current data object */
-  data;
-  /** Ref data for template rendering */
-  refData;
-  /** Changed keys in current digest cycle */
-  changedKeys = /* @__PURE__ */ new Set();
-  /** Whether data has changed since last digest */
-  hasChangedFlag = 0;
-  /**
-   * 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.
-   */
-  digestingQueue = [];
-  /** Monotonically increasing version, bumped each time data actually changes. */
-  version = 0;
-  /** Snapshot of `version` taken by `snapshot()`, used by `altered()`. */
-  snapshotVersion;
-  /** Last rendered VDOM tree (only used when virtualDom is enabled) */
-  vdom;
-  constructor(viewId) {
-    this.viewId = viewId;
-    this.data = { vId: viewId };
-    const refCounter = {};
-    refCounter[SPLITTER] = 1;
-    this.refData = refCounter;
-    this.hasChangedFlag = 1;
-  }
-  /**
-   * Get data by key.
-   * Returns entire data object if key is omitted.
-   */
-  get(key) {
-    let result = this.data;
+function createUpdater(viewId) {
+  let data = { vId: viewId };
+  const refData = {};
+  refData[SPLITTER] = 1;
+  let changedKeys2 = /* @__PURE__ */ new Set();
+  let hasChangedFlag = 0;
+  const digestingQueue = [];
+  let version = 0;
+  let snapshotVersion;
+  let vdom;
+  hasChangedFlag = 1;
+  function get(key) {
+    let result = data;
     if (key) {
-      result = this.data[key];
+      result = data[key];
     }
     return result;
   }
-  /**
-   * Set data, tracking changed keys.
-   * Returns this for chaining.
-   */
-  set(data, excludes) {
-    const changed = setData(
-      data,
-      this.data,
-      this.changedKeys,
-      excludes || EMPTY_STRING_SET
-    );
+  function set(newData, excludes) {
+    const changed = setData(newData, data, changedKeys2, excludes || EMPTY_STRING_SET);
     if (changed) {
-      this.version++;
-      this.hasChangedFlag = 1;
+      version++;
+      hasChangedFlag = 1;
     }
-    return this;
+    return api;
   }
-  /**
-   * Detect changes and trigger DOM re-render.
-   *
-   * The core rendering pipeline:
-   * 1. Set data if provided
-   * 2. If changed, run DOM 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, excludes, callback) {
-    if (data) {
-      this.set(data, excludes);
+  function digest(newData, excludes, callback) {
+    if (newData) {
+      set(newData, excludes);
     }
-    const digesting = this.digestingQueue;
     if (callback) {
-      digesting.push(callback);
+      digestingQueue.push(callback);
     }
-    if (digesting.length > 0 && digesting[0] === null) {
+    if (digestingQueue.length > 0 && digestingQueue[0] === null) {
       return;
     }
-    this.runDigest(digesting);
+    runDigest(digestingQueue);
   }
-  /**
-   * Core digest execution.
-   */
-  runDigest(digesting) {
+  function runDigest(digesting) {
     const startIndex = digesting.length;
     digesting.push(null);
-    const keys2 = this.changedKeys;
-    const changed = this.hasChangedFlag;
-    this.hasChangedFlag = 0;
-    this.changedKeys = /* @__PURE__ */ new Set();
-    const frame = getFrame(this.viewId);
+    const keys2 = changedKeys2;
+    const changed = hasChangedFlag;
+    const frame = Frame.get(viewId);
     const view = frame?.view;
-    const node = getById(this.viewId);
-    if (changed && view && node && view.signature > 0 && frame) {
-      const template = view.template;
+    const node = getById(viewId);
+    if (changed && view && node && view.signature.value > 0 && frame) {
+      hasChangedFlag = 0;
+      changedKeys2 = /* @__PURE__ */ new Set();
+      const template = view.getTemplate();
       if (typeof template === "function") {
-        if (config.virtualDom) {
-          const vdomTemplate = template;
-          const newVDom = vdomTemplate(this.data, this.viewId, this.refData);
-          const ref = createVDomRef(this.viewId);
+        const result = template(
+          data,
+          viewId,
+          refData,
+          encodeHTML,
+          strSafe,
+          encodeURIExtra,
+          refFn,
+          encodeQuote
+        );
+        if (typeof result === "string") {
+          const newDom = domGetNode(result, node);
+          const ref = createDomRef();
+          domSetChildNodes(node, newDom, ref, frame, keys2);
+          applyIdUpdates(ref.idUpdates);
+          applyDomOps(ref.domOps);
+          for (const v of ref.views) {
+            if (v.render) {
+              funcWithTry(v.render, [], v, noop);
+            }
+          }
+          if (ref.hasChanged || !view.rendered.value) {
+            view.endUpdate(viewId);
+          }
+        } else {
+          const newVDom = result;
+          const ref = createVDomRef(viewId);
           const ready = () => {
-            this.vdom = newVDom;
-            if (ref.changed || !view.rendered) {
-              view.endUpdate(this.viewId);
+            vdom = newVDom;
+            if (ref.changed || !view.rendered.value) {
+              view.endUpdate(viewId);
             }
             for (const [el, prop, val] of ref.nodeProps) {
               Reflect.set(el, prop, val);
@@ -2320,45 +2119,14 @@ var Updater = class {
               }
             }
           };
-          vdomSetChildNodes(
-            node,
-            this.vdom,
-            newVDom,
-            ref,
-            frame,
-            keys2,
-            view,
-            ready
-          );
-        } else {
-          const html = template(
-            this.data,
-            this.viewId,
-            this.refData,
-            encodeHTML,
-            strSafe,
-            encodeURIExtra,
-            refFn,
-            encodeQuote
-          );
-          const newDom = domGetNode(html, node);
-          const ref = createDomRef();
-          domSetChildNodes(node, newDom, ref, frame, keys2);
-          applyIdUpdates(ref.idUpdates);
-          applyDomOps(ref.domOps);
-          for (const v of ref.views) {
-            if (v.render) {
-              funcWithTry(v.render, [], v, noop);
-            }
-          }
-          if (ref.hasChanged || !view.rendered) {
-            view.endUpdate(this.viewId);
-          }
+          vdomSetChildNodes(node, vdom, newVDom, ref, frame, keys2, view, ready);
         }
       }
+    } else {
+      changedKeys2 = /* @__PURE__ */ new Set();
     }
     if (digesting.length > startIndex + 1) {
-      this.runDigest(digesting);
+      runDigest(digesting);
     } else {
       const callbacks = digesting.slice();
       digesting.length = 0;
@@ -2367,44 +2135,19 @@ var Updater = class {
       }
     }
   }
-  /**
-   * Save a snapshot of the current data version for `altered()` detection.
-   * Cheap O(1) — records the current monotonic version, no serialization.
-   */
-  snapshot() {
-    this.snapshotVersion = this.version;
-    return this;
+  function snapshot() {
+    snapshotVersion = version;
+    return api;
   }
-  /**
-   * Check whether data has changed since the last snapshot.
-   * Returns undefined when no snapshot has been taken yet.
-   */
-  altered() {
-    if (this.snapshotVersion === void 0) return void 0;
-    return this.version !== this.snapshotVersion;
+  function altered() {
+    if (snapshotVersion === void 0) return void 0;
+    return version !== snapshotVersion;
   }
-  /**
-   * Translate a refData reference back to its original value.
-   *
-   * The ref protocol is `SPLITTER` + ascii decimal digits — the exact format
-   * emitted by `refFn`. 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) {
-    if (typeof data !== "string" || !isRefToken(data)) return data;
-    return hasOwnProperty(this.refData, data) ? this.refData[data] : data;
+  function translate(dataVal) {
+    if (typeof dataVal !== "string" || !isRefToken(dataVal)) return dataVal;
+    return hasOwnProperty(refData, dataVal) ? refData[dataVal] : dataVal;
   }
-  /**
-   * 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) {
+  function parse(expr) {
     const trimmed = expr.trim();
     if (!trimmed) return void 0;
     if (/^-?\d+(?:\.\d+)?$/.test(trimmed)) {
@@ -2413,245 +2156,329 @@ var Updater = class {
     if (!/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*$/.test(trimmed)) {
       return void 0;
     }
-    let cur = this.refData;
+    let cur = refData;
     for (const segment of trimmed.split(".")) {
       if (cur == null || typeof cur !== "object") return void 0;
-      cur = cur[segment];
+      cur = Reflect.get(cur, segment);
     }
     return cur;
   }
-  /**
-   * Get the set of keys changed since the last digest (for external inspection).
-   */
-  getChangedKeys() {
-    return this.changedKeys;
-  }
-};
-
-// src/view-registry.ts
-var viewClassRegistry = {};
-function getViewClass(path) {
-  return viewClassRegistry[path];
-}
-function registerViewClass(viewPath, ViewClass) {
-  const parsed = parseUri(viewPath);
-  const path = parsed.path;
-  if (path) {
-    viewClassRegistry[path] = ViewClass;
-  }
+  function getChangedKeys() {
+    return changedKeys2;
+  }
+  function forceDigest() {
+    hasChangedFlag = 1;
+    changedKeys2 = new Set(Object.keys(data));
+    digest();
+  }
+  const api = {
+    get,
+    set,
+    digest,
+    forceDigest,
+    snapshot,
+    altered,
+    refData,
+    translate,
+    parse,
+    getChangedKeys
+  };
+  return api;
 }
-function invalidateViewClass(viewPath) {
-  const parsed = parseUri(viewPath);
-  const path = parsed.path;
-  if (path) {
-    Reflect.deleteProperty(viewClassRegistry, path);
-  }
+
+// src/store.ts
+var COMPUTED_BRAND = /* @__PURE__ */ Symbol("lark-store-computed");
+function isComputedMarker(val) {
+  return val !== null && typeof val === "object" && Reflect.get(val, COMPUTED_BRAND) === true;
 }
-function getViewClassRegistry() {
-  return viewClassRegistry;
+function computed(deps, fn) {
+  return { [COMPUTED_BRAND]: true, deps, fn };
 }
-
-// src/hmr.ts
-function reloadViews(viewPath) {
-  const allFrames = getAllFrames();
-  const toReload = [];
-  for (const [, frame] of allFrames) {
-    if (frame.viewPath) {
-      const parsed = parseUri(frame.viewPath);
-      if (parsed.path === viewPath) {
-        toReload.push({ frame, fullPath: frame.viewPath });
+var storeRegistry = /* @__PURE__ */ new Map();
+function createStore(name, creator) {
+  const listeners = /* @__PURE__ */ new Set();
+  const computedDefs = /* @__PURE__ */ new Map();
+  const computedKeys = /* @__PURE__ */ new Set();
+  const actionKeys = /* @__PURE__ */ new Set();
+  let state;
+  let destroyed = false;
+  const getState = () => state;
+  const setState = (partial) => {
+    if (destroyed) return;
+    const prevState = state;
+    const resolved = typeof partial === "function" ? partial(prevState) : partial;
+    const nextState = { ...prevState };
+    let changed = false;
+    for (const key in resolved) {
+      if (Object.prototype.hasOwnProperty.call(resolved, key) && !computedKeys.has(key) && !actionKeys.has(key)) {
+        const newVal = Reflect.get(resolved, key);
+        if (!Object.is(Reflect.get(prevState, key), newVal)) {
+          Reflect.set(nextState, key, newVal);
+          changed = true;
+        }
+      }
+    }
+    if (!changed) return;
+    state = nextState;
+    recomputeIfNeeded(prevState);
+    for (const listener of listeners) {
+      listener(state, prevState);
+    }
+  };
+  const recomputeIfNeeded = (prevState) => {
+    if (computedDefs.size === 0) return;
+    const changedKeys2 = /* @__PURE__ */ new Set();
+    for (const key of Object.keys(state)) {
+      if (!Object.is(Reflect.get(state, key), Reflect.get(prevState, key))) {
+        changedKeys2.add(key);
+      }
+    }
+    for (const [key, def] of computedDefs) {
+      if (def.deps.some((dep) => changedKeys2.has(dep))) {
+        const newVal = def.fn();
+        if (!Object.is(Reflect.get(state, key), newVal)) {
+          Reflect.set(state, key, newVal);
+        }
       }
     }
+  };
+  const subscribe = (listener) => {
+    listeners.add(listener);
+    return () => {
+      listeners.delete(listener);
+    };
+  };
+  const destroy = () => {
+    destroyed = true;
+    listeners.clear();
+    storeRegistry.delete(name);
+  };
+  const api = { getState, setState, subscribe, destroy };
+  const body = creator(setState, getState);
+  const initialState = {};
+  const actions = {};
+  for (const key of Object.keys(body)) {
+    const val = Reflect.get(body, key);
+    if (isComputedMarker(val)) {
+      computedDefs.set(key, val);
+      computedKeys.add(key);
+      initialState[key] = void 0;
+    } else if (typeof val === "function") {
+      Reflect.set(actions, key, val);
+      actionKeys.add(key);
+    } else {
+      initialState[key] = val;
+    }
   }
-  for (const { frame, fullPath } of toReload) {
-    frame.mountView(fullPath);
+  state = { ...initialState, ...actions };
+  for (const [key, def] of computedDefs) {
+    Reflect.set(state, key, def.fn());
   }
+  storeRegistry.set(name, api);
+  return api;
 }
-function acceptView(hot, viewPath) {
-  hot.accept((newModule) => {
-    const candidate = newModule?.default ?? newModule;
-    if (typeof candidate === "function") {
-      const NewViewClass = candidate;
-      registerViewClass(viewPath, NewViewClass);
-      reloadViews(viewPath);
-      return;
-    }
-    if (getViewClass(viewPath)) {
-      reloadViews(viewPath);
-      return;
-    }
-    hot.invalidate();
-  });
+function isLarkView(instance) {
+  if (!instance || typeof instance !== "object") return false;
+  const updater = Reflect.get(instance, "updater");
+  return updater !== null && typeof updater === "object" && typeof Reflect.get(updater, "set") === "function" && typeof Reflect.get(updater, "digest") === "function";
 }
-function disposeView(hot, viewPath) {
-  hot.dispose(() => {
-    invalidateViewClass(viewPath);
+function bindStore(view, store, selector) {
+  if (!isLarkView(view)) return () => {
+  };
+  const extract = (s) => {
+    if (selector) return selector(s);
+    const result = {};
+    for (const key in s) {
+      if (Object.prototype.hasOwnProperty.call(s, key) && typeof s[key] !== "function") {
+        result[key] = s[key];
+      }
+    }
+    return result;
+  };
+  view.updater.set(extract(store.getState()));
+  view.updater.digest();
+  const off = store.subscribe((state) => {
+    view.updater.set(extract(state));
+    view.updater.digest();
   });
+  view.on("destroy", off);
+  return off;
 }
 
-// src/view.ts
-var VIEW_GLOBALS = {};
-if (typeof window !== "undefined") {
-  VIEW_GLOBALS["window"] = window;
+// src/hooks.ts
+var currentCtx = null;
+function setCurrentCtx(ctx) {
+  currentCtx = ctx;
 }
-if (typeof document !== "undefined") {
-  VIEW_GLOBALS["document"] = document;
+function getCtx() {
+  if (!currentCtx) {
+    throw new Error("Hooks can only be called inside a view setup function");
+  }
+  return currentCtx;
 }
-var View = class _View {
-  /** View ID (same as owner frame ID) */
-  id = "";
-  /** Owner frame */
-  owner = 0;
-  /** Updater instance */
-  updater;
-  /** Signature: > 0 means active, incremented on render, 0 = destroyed */
-  signature = 0;
-  /** Whether rendered at least once */
-  rendered;
-  /** Whether view has template */
-  template;
-  /** Location observation config */
-  locationObserved = {
-    flag: 0,
-    keys: [],
-    observePath: false
+function useState(key, initial) {
+  const ctx = getCtx();
+  const existing = ctx.updater.get(key);
+  if (existing === void 0) {
+    ctx.updater.set({ [key]: initial });
+  }
+  const getter = () => ctx.updater.get(key);
+  const setter = (v) => {
+    ctx.updater.set({ [key]: v }).digest();
   };
-  /** Observed state keys */
-  observedStateKeys;
-  /** Resource map */
-  resources = {};
-  /** Whether endUpdate pending */
-  endUpdatePending;
-  /** Internal event storage */
-  _events = new EventEmitter();
-  // ============================================================
-  // Getters for prototype-stored event maps
-  // ============================================================
-  /** Prototype-stored event maps shape (set by View.prepare). */
-  get protoEventState() {
-    return Object.getPrototypeOf(this);
-  }
-  /**
-   * Event bitmask map: eventType -> bitmask (1=root, 2=selector).
-   * Read from prototype ($evtObjMap) set by View.prepare.
-   * Using a getter avoids ES6 class field shadowing the prototype value.
-   */
-  get eventObjectMap() {
-    return this.protoEventState.$evtObjMap ?? {};
-  }
-  /**
-   * Selector event map: eventType -> selector list.
-   * Read from prototype ($selMap) set by View.prepare.
-   */
-  get eventSelectorMap() {
-    return this.protoEventState.$selMap ?? {};
+  return [getter, setter];
+}
+function useEffect(fn, _deps) {
+  const ctx = getCtx();
+  const cleanup = fn();
+  if (typeof cleanup === "function") {
+    ctx.cleanups.push(cleanup);
   }
-  /**
-   * Global event list: [{handler, element, eventName, modifiers}].
-   * Read from prototype ($globalEvtList) set by View.prepare.
-   */
-  get globalEventList() {
-    return this.protoEventState.$globalEvtList ?? [];
+}
+function useStore(store, selector) {
+  const ctx = getCtx();
+  bindStore(ctx, store, selector);
+  if (selector) {
+    return () => {
+      const state = store.getState();
+      return selector(state);
+    };
   }
-  // ============================================================
-  // Instance lifecycle methods
-  // ============================================================
-  /**
-   * Initialize view (called by Frame when mounting).
-   */
-  init() {
+  return () => {
+    const data = ctx.updater.get();
+    const result = {};
+    for (const key of Object.keys(data)) {
+      if (key !== "vId" && typeof data[key] !== "function") {
+        result[key] = data[key];
+      }
+    }
+    return result;
+  };
+}
+function useInterval(fn, delay) {
+  const ctx = getCtx();
+  const timer = setInterval(fn, delay);
+  ctx.cleanups.push(() => clearInterval(timer));
+}
+function useTimeout(fn, delay) {
+  const ctx = getCtx();
+  const timer = setTimeout(fn, delay);
+  ctx.cleanups.push(() => clearTimeout(timer));
+}
+function useResource(key, resource, destroyOnRender = false) {
+  const ctx = getCtx();
+  ctx.capture(key, resource, destroyOnRender);
+}
+function useEvent(event, handler) {
+  const ctx = getCtx();
+  const off = ctx.on(event, handler);
+  ctx.cleanups.push(off);
+}
+
+// src/view.ts
+var VIEW_GLOBALS = {};
+if (typeof window !== "undefined") {
+  VIEW_GLOBALS["window"] = window;
+}
+if (typeof document !== "undefined") {
+  VIEW_GLOBALS["document"] = document;
+}
+function defineView(setup) {
+  return setup;
+}
+function createCtx(frame) {
+  const id = frame.id;
+  const updater = createUpdater(id);
+  const emitter3 = createEmitter();
+  const signature = { value: 0 };
+  const rendered = { value: false };
+  const resources = {};
+  const locationObserved = {
+    flag: 0,
+    keys: [],
+    observePath: false
+  };
+  const mutable = {
+    observedStateKeys: void 0,
+    endUpdatePending: void 0,
+    template: void 0,
+    events: void 0,
+    assignFn: void 0
+  };
+  const cleanups = [];
+  function on(event, handler) {
+    emitter3.on(event, handler);
+    return () => emitter3.off(event, handler);
   }
-  /**
-   * Render view template (called by Frame after init).
-   * Wrapped by View.wrapMethod to manage signature + resources.
-   */
-  render() {
-    this.updater.digest();
+  function off(event, handler) {
+    emitter3.off(event, handler);
   }
-  // ============================================================
-  // Event methods (delegate to internal EventEmitter)
-  // ============================================================
-  on(event, handler) {
-    this._events.on(event, handler);
-    return this;
+  function fire(event, data, remove, lastToFirst) {
+    emitter3.fire(event, data, remove, lastToFirst);
   }
-  off(event, handler) {
-    this._events.off(event, handler);
-    return this;
+  function capture(key, resource, destroyOnRender = false) {
+    if (resource !== void 0) {
+      destroyResource(resources, key, true, resource);
+      resources[key] = { entity: resource, destroyOnRender };
+    } else {
+      const entry = resources[key];
+      return entry ? entry.entity : void 0;
+    }
+    return resource;
   }
-  fire(event, data, remove, lastToFirst) {
-    this._events.fire(event, data, remove, lastToFirst);
-    return this;
+  function release(key, destroy = true) {
+    return destroyResource(resources, key, destroy);
   }
-  // ============================================================
-  // Update methods
-  // ============================================================
-  /** Get the owning frame, asserting it has been bound. */
-  get ownerFrame() {
-    return this.owner;
+  function render() {
+    if (signature.value > 0) {
+      signature.value++;
+      fire("render");
+      destroyAllResources(ctx, false);
+      if (typeof ctx.renderMethod === "function") {
+        funcWithTry(ctx.renderMethod, [], ctx, noop);
+      } else {
+        updater.digest();
+      }
+    }
   }
-  /**
-   * Notify view that HTML update is about to begin.
-   * Unmounts child frames in the update zone.
-   */
-  beginUpdate(id) {
-    if (this.signature > 0 && this.endUpdatePending !== void 0) {
-      this.ownerFrame.unmountZone(id);
+  function beginUpdate(zoneId) {
+    if (signature.value > 0 && mutable.endUpdatePending !== void 0) {
+      frame.unmountZone(zoneId);
     }
   }
-  /**
-   * Notify view that HTML update has ended.
-   * Mounts child frames in the update zone and runs deferred invokes.
-   */
-  endUpdate(id, inner) {
-    if (this.signature > 0) {
-      const updateId = id || this.id;
+  function endUpdate(zoneId, inner) {
+    if (signature.value > 0) {
+      const updateId = zoneId ?? id;
       let flag;
       if (inner) {
         flag = inner;
       } else {
-        flag = this.endUpdatePending;
-        this.endUpdatePending = 1;
-        this.rendered = true;
+        flag = mutable.endUpdatePending;
+        mutable.endUpdatePending = 1;
+        rendered.value = true;
       }
-      const ownerFrame = this.ownerFrame;
-      ownerFrame.mountZone(updateId);
+      frame.mountZone(updateId);
       if (!flag) {
         setTimeout(
-          this.wrapAsync(() => {
-            _View.runInvokes(ownerFrame);
+          wrapAsync(() => {
+            runInvokes(frame);
           }),
           0
         );
       }
     }
   }
-  // ============================================================
-  // Async wrapper
-  // ============================================================
-  /**
-   * 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, context) {
-    const currentSignature = this.signature;
+  function wrapAsync(fn, context) {
+    const currentSignature = signature.value;
     return (...args) => {
-      if (currentSignature > 0 && currentSignature === this.signature) {
-        return fn.apply(context || this, args);
+      if (currentSignature > 0 && currentSignature === signature.value) {
+        return fn.apply(context ?? ctx, args);
       }
       return void 0;
     };
   }
-  // ============================================================
-  // Location observation
-  // ============================================================
-  /**
-   * Observe location parameters or path changes.
-   * When observed keys change, render() is called automatically.
-   */
-  observeLocation(params, observePath = false) {
-    const loc = this.locationObserved;
-    loc.flag = 1;
+  function observeLocation(params, observePath = false) {
+    locationObserved.flag = 1;
     if (typeof params === "object" && !Array.isArray(params)) {
       const opts = params;
       if (opts["path"]) {
@@ -2662,883 +2489,644 @@ var View = class _View {
         params = paramKeys;
       }
     }
-    loc.observePath = observePath;
+    locationObserved.observePath = observePath;
     if (params) {
       if (typeof params === "string") {
-        loc.keys = params.split(",");
+        locationObserved.keys = params.split(",");
       } else if (Array.isArray(params)) {
-        loc.keys = params;
+        locationObserved.keys = params;
       }
     }
   }
-  // ============================================================
-  // State observation
-  // ============================================================
-  /**
-   * Observe State data keys for changes.
-   * When observed keys change via State.digest(), render() is called.
-   */
-  observeState(observedKeys) {
-    if (typeof observedKeys === "string") {
-      this.observedStateKeys = observedKeys.split(",");
+  function observeState(keys2) {
+    if (typeof keys2 === "string") {
+      mutable.observedStateKeys = keys2.split(",");
     } else {
-      this.observedStateKeys = observedKeys;
+      mutable.observedStateKeys = keys2;
     }
   }
-  // ============================================================
-  // Resource management
-  // ============================================================
-  /**
-   * 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, resource, destroyOnRender = false) {
-    const cache = this.resources;
-    if (resource) {
-      _View.destroyResource(cache, key, true, resource);
-      cache[key] = {
-        entity: resource,
-        destroyOnRender
-      };
-    } else {
-      const entry = cache[key];
-      return entry ? entry.entity : void 0;
+  function leaveTip(message, condition) {
+    const changeState = { a: 0, b: 0 };
+    function isRouteChange(e) {
+      return "prevent" in e && "reject" in e && "resolve" in e;
     }
-    return resource;
-  }
-  /**
-   * Release a captured resource.
-   * If destroy=true, calls the resource's destroy() method.
-   */
-  release(key, destroy = true) {
-    return _View.destroyResource(this.resources, key, destroy);
-  }
-  // ============================================================
-  // Leave tip
-  // ============================================================
-  /**
-   * Set up a leave confirmation for route changes and page unload.
-   */
-  leaveTip(message, condition) {
-    const changeListener = function(e) {
+    const changeListener = (e) => {
+      if (!e) return;
       const isRouterChange = e.type === RouterEvents.CHANGE;
       const aKey = isRouterChange ? "a" : "b";
       const bKey = isRouterChange ? "b" : "a";
-      if (changeListener[aKey]) {
-        e.prevent?.();
-        e.reject?.();
+      if (changeState[aKey]) {
+        if (isRouteChange(e)) {
+          e.prevent();
+          e.reject();
+        }
       } else if (condition()) {
-        e.prevent?.();
-        changeListener[bKey] = 1;
-        e.resolve?.();
+        if (isRouteChange(e)) {
+          e.prevent();
+          changeState[bKey] = 1;
+          e.resolve();
+        }
       }
     };
     const unloadListener = (e) => {
-      if (condition()) {
-        e["msg"] = message;
+      if (e && condition()) {
+        Reflect.set(e, "msg", message);
       }
     };
     Router.on(RouterEvents.CHANGE, changeListener);
     Router.on(RouterEvents.PAGE_UNLOAD, unloadListener);
-    this.on("unload", changeListener);
-    this.on("destroy", () => {
+    on("unload", changeListener);
+    on("destroy", () => {
       Router.off(RouterEvents.CHANGE, changeListener);
       Router.off(RouterEvents.PAGE_UNLOAD, unloadListener);
     });
   }
-  // ============================================================
-  // Static public methods
-  // ============================================================
-  /** Collected makes from mixins */
-  static makes;
-  /**
-   * Prepare a View subclass by scanning its prototype for event method patterns.
-   * Pattern: `$?name<eventType1,eventType2>(&modifiers)`
-   *
-   * Only runs once per View subclass (guarded by makes marker).
-   * Called from Frame.mountView before creating the view instance.
-   */
-  static prepare(oView) {
-    if (oView.makes) {
-      return oView.makes;
-    }
-    const makes = [];
-    oView.makes = makes;
-    const eventsObject = {};
-    const eventsList = [];
-    const selectorObject = {};
-    const mixins = Reflect.get(oView.prototype, "mixins");
-    if (mixins && Array.isArray(mixins)) {
-      _View.mergeMixins(mixins, oView, makes);
-    }
-    for (const p in oView.prototype) {
-      if (!hasOwnProperty(oView.prototype, p)) continue;
-      const currentFn = Reflect.get(oView.prototype, p);
-      if (typeof currentFn !== "function") continue;
-      const matches = p.match(VIEW_EVENT_METHOD_REGEXP);
-      if (!matches) continue;
-      const isSelector = matches[1];
-      const selectorOrCallback = matches[2];
-      const events = matches[3];
-      const modifiers = matches[4];
-      const mod = {};
-      if (modifiers) {
-        for (const item of modifiers.split(",")) {
-          mod[item] = true;
-        }
-      }
-      const eventTypes = events.split(",");
-      for (const item of eventTypes) {
-        const globalNode = VIEW_GLOBALS[selectorOrCallback];
-        let mask = 1;
-        if (isSelector) {
-          if (globalNode) {
-            eventsList.push({
-              handler: currentFn,
-              element: globalNode,
-              eventName: item,
-              modifiers: mod
-            });
-            continue;
-          }
-          mask = 2;
-          let selectorEntry = selectorObject[item];
-          if (!selectorEntry) {
-            selectorEntry = selectorObject[item] = {
-              selectors: []
-            };
-          }
-          if (!selectorEntry[selectorOrCallback]) {
-            selectorEntry[selectorOrCallback] = 1;
-            selectorEntry.selectors.push(selectorOrCallback);
-          }
-        }
-        eventsObject[item] = (eventsObject[item] || 0) | mask;
-        const combinedKey = selectorOrCallback + SPLITTER + item;
-        const existingFn = Reflect.get(oView.prototype, combinedKey);
-        if (!existingFn) {
-          Reflect.set(oView.prototype, combinedKey, currentFn);
-        } else if (typeof existingFn === "function") {
-          const mixinFn = currentFn;
-          const existingMixin = existingFn;
-          if (existingMixin.marker) {
-            if (mixinFn.marker) {
-              Reflect.set(
-                oView.prototype,
-                combinedKey,
-                _View.processMixinsSameEvent(mixinFn, existingMixin)
-              );
-            } else if (hasOwnProperty(oView.prototype, p)) {
-              Reflect.set(oView.prototype, combinedKey, currentFn);
-            }
-          }
-        }
+  function init(_params) {
+  }
+  function getTemplate() {
+    return mutable.template;
+  }
+  function setTemplate(v) {
+    mutable.template = v;
+  }
+  function getObservedStateKeys() {
+    return mutable.observedStateKeys;
+  }
+  function setObservedStateKeys(v) {
+    mutable.observedStateKeys = v;
+  }
+  function getEndUpdatePending() {
+    return mutable.endUpdatePending;
+  }
+  function setEndUpdatePending(v) {
+    mutable.endUpdatePending = v;
+  }
+  function getEvents() {
+    return mutable.events;
+  }
+  function setEvents(v) {
+    mutable.events = v;
+  }
+  function getAssign() {
+    return mutable.assignFn;
+  }
+  function setAssign(v) {
+    mutable.assignFn = v;
+  }
+  const ctx = {
+    id,
+    owner: frame,
+    updater,
+    signature,
+    rendered,
+    getTemplate,
+    setTemplate,
+    locationObserved,
+    getObservedStateKeys,
+    setObservedStateKeys,
+    resources,
+    emitter: emitter3,
+    getEndUpdatePending,
+    setEndUpdatePending,
+    getEvents,
+    setEvents,
+    cleanups,
+    getAssign,
+    setAssign,
+    render,
+    init,
+    beginUpdate,
+    endUpdate,
+    wrapAsync,
+    observeLocation,
+    observeState,
+    capture,
+    release,
+    leaveTip,
+    fire,
+    on,
+    off
+  };
+  return ctx;
+}
+function registerEvents(ctx) {
+  const events = ctx.getEvents();
+  if (!events) return;
+  for (const key of Object.keys(events)) {
+    if (!hasOwnProperty(events, key)) continue;
+    const handler = events[key];
+    if (typeof handler !== "function") continue;
+    const matches = key.match(VIEW_EVENT_METHOD_REGEXP);
+    if (!matches) continue;
+    const isSelector = matches[1];
+    const selectorOrCallback = matches[2];
+    const eventTypes = matches[3];
+    const modifiers = matches[4];
+    const mod = {};
+    if (modifiers) {
+      for (const item of modifiers.split(",")) {
+        mod[item] = true;
       }
     }
-    _View.wrapMethod(asRecord(oView.prototype), "render", "$renderWrap");
-    Reflect.set(oView.prototype, "$evtObjMap", eventsObject);
-    Reflect.set(oView.prototype, "$globalEvtList", eventsList);
-    Reflect.set(oView.prototype, "$selMap", selectorObject);
-    return makes;
-  }
-  /**
-   * Bind or unbind event delegation for a view instance.
-   * Called from Frame during mount/unmount.
-   */
-  static delegateEvents(view, destroy = false) {
-    const eventsObject = view.eventObjectMap;
-    const selectorObject = view.eventSelectorMap;
-    const eventsList = view.globalEventList;
-    for (const e in eventsObject) {
-      if (hasOwnProperty(eventsObject, e)) {
-        if (destroy) {
-          EventDelegator.unbind(e, !!selectorObject[e]);
-        } else {
-          EventDelegator.bind(e, !!selectorObject[e]);
-        }
+    for (const eventType of eventTypes.split(",")) {
+      const globalNode = VIEW_GLOBALS[selectorOrCallback];
+      if (isSelector && globalNode) {
+        registerGlobalEvent(ctx, globalNode, eventType, handler, mod, key);
+      } else if (isSelector) {
+        EventDelegator.bind(eventType, true);
+      } else {
+        EventDelegator.bind(eventType, false);
       }
     }
-    for (const entry of eventsList) {
-      if (destroy) {
-        entry.element.removeEventListener(
-          entry.eventName,
-          entry.boundHandler
-        );
+  }
+}
+function unregisterEvents(ctx) {
+  const events = ctx.getEvents();
+  if (!events) return;
+  for (const key of Object.keys(events)) {
+    if (!hasOwnProperty(events, key)) continue;
+    const matches = key.match(VIEW_EVENT_METHOD_REGEXP);
+    if (!matches) continue;
+    const isSelector = matches[1];
+    const selectorOrCallback = matches[2];
+    const eventTypes = matches[3];
+    for (const eventType of eventTypes.split(",")) {
+      const globalNode = VIEW_GLOBALS[selectorOrCallback];
+      if (isSelector && globalNode) {
+      } else if (isSelector) {
+        EventDelegator.unbind(eventType, true);
       } else {
-        const handler = entry.handler;
-        const element = entry.element;
-        const modifiers = entry.modifiers;
-        entry.boundHandler = function(domEvent) {
-          const extendedEvent = domEvent;
-          extendedEvent.eventTarget = element;
-          if (modifiers) {
-            const kbEvent = domEvent;
-            if (modifiers["ctrl"] && !kbEvent.ctrlKey || modifiers["shift"] && !kbEvent.shiftKey || modifiers["alt"] && !kbEvent.altKey || modifiers["meta"] && !kbEvent.metaKey) {
-              return;
-            }
-          }
-          funcWithTry(handler, [domEvent], view, noop);
-        };
-        entry.element.addEventListener(
-          entry.eventName,
-          entry.boundHandler
-        );
+        EventDelegator.unbind(eventType, false);
       }
     }
   }
-  /**
-   * Destroy all resources managed by a view.
-   * If lastly=true, destroy ALL resources; otherwise only destroyOnRender ones.
-   */
-  static destroyAllResources(view, lastly) {
-    const cache = view.resources;
-    for (const p in cache) {
-      if (hasOwnProperty(cache, p)) {
-        const entry = cache[p];
-        if (lastly || entry.destroyOnRender) {
-          _View.destroyResource(cache, p, true);
+  EventDelegator.clearRangeEvents(ctx.id);
+}
+function registerGlobalEvent(ctx, element, eventName, handler, modifiers, _key) {
+  const listener = {
+    handleEvent(domEvent) {
+      Reflect.set(domEvent, "eventTarget", element);
+      if (modifiers) {
+        const ctrlKey = Reflect.get(domEvent, "ctrlKey");
+        const shiftKey = Reflect.get(domEvent, "shiftKey");
+        const altKey = Reflect.get(domEvent, "altKey");
+        const metaKey = Reflect.get(domEvent, "metaKey");
+        if (modifiers["ctrl"] && !ctrlKey || modifiers["shift"] && !shiftKey || modifiers["alt"] && !altKey || modifiers["meta"] && !metaKey) {
+          return;
         }
       }
+      funcWithTry(handler, [domEvent], ctx, noop);
     }
-  }
-  /**
-   * Process deferred invoke calls on a frame.
-   */
-  static runInvokes(frame) {
-    const list = frame.invokeList;
-    if (!list) return;
-    while (list.length) {
-      const entry = list.shift();
-      if (entry && !entry.removed) {
-        frame.invoke(entry.name, entry.args);
+  };
+  element.addEventListener(eventName, listener);
+  ctx.on("destroy", () => {
+    element.removeEventListener(eventName, listener);
+  });
+}
+function destroyAllResources(ctx, lastly) {
+  const cache = ctx.resources;
+  for (const p in cache) {
+    if (hasOwnProperty(cache, p)) {
+      const entry = cache[p];
+      if (lastly || entry.destroyOnRender) {
+        destroyResource(cache, p, true);
       }
     }
   }
-  // ============================================================
-  // Static private methods
-  // ============================================================
-  /**
-   * Wrap a method on the prototype to add signature checking and resource cleanup.
-   */
-  static wrapMethod(proto, fnName, shortKey) {
-    const originalFn = proto[fnName];
-    if (typeof originalFn !== "function") return;
-    const originalAsFn = originalFn;
-    const wrapped = function(...args) {
-      if (this.signature > 0) {
-        this.signature++;
-        this.fire("render");
-        _View.destroyAllResources(this, false);
-        const lookup = asRecord(this);
-        const candidate = lookup[fnName];
-        const instanceFn = typeof candidate === "function" ? candidate : originalAsFn;
-        const fnToCall = instanceFn === wrapped ? originalAsFn : instanceFn;
-        return funcWithTry(fnToCall, args, this, noop);
-      }
-      return void 0;
-    };
-    proto[fnName] = wrapped;
-    proto[shortKey] = wrapped;
+}
+function destroyResource(cache, key, callDestroy, oldEntity) {
+  const entry = cache[key];
+  if (!entry || entry.entity === oldEntity) return void 0;
+  const entity = entry.entity;
+  if (entity && typeof entity === "object") {
+    const destroyFn = Reflect.get(entity, "destroy");
+    if (typeof destroyFn === "function" && callDestroy) {
+      funcWithTry(destroyFn, [], entity, noop);
+    }
+  }
+  Reflect.deleteProperty(cache, key);
+  return entity;
+}
+function runInvokes(frame) {
+  const list = frame.invokeList;
+  if (!list) return;
+  while (list.length) {
+    const entry = list.shift();
+    if (entry && !entry.removed) {
+      frame.invoke(entry.name, entry.args);
+    }
   }
-  /**
-   * When two mixins define the same event method, merge them into
-   * a single function that calls both in sequence.
-   */
-  static processMixinsSameEvent(additional, exist) {
-    let temp;
-    if (exist.handlerList) {
-      temp = exist;
-    } else {
-      const merged = function(...e) {
-        funcWithTry(merged.handlerList ?? [], e, this, noop);
-      };
-      merged.handlerList = [exist];
-      merged.marker = 1;
-      temp = merged;
-    }
-    temp.handlerList = (temp.handlerList ?? []).concat(
-      additional.handlerList ?? [additional]
-    );
-    return temp;
+}
+function mountCtx(frame, setup, params) {
+  const ctx = createCtx(frame);
+  setCurrentCtx(ctx);
+  let descriptor;
+  try {
+    descriptor = setup(ctx, params);
+  } finally {
+    setCurrentCtx(null);
+  }
+  ctx.setTemplate(descriptor.template);
+  ctx.setEvents(descriptor.events);
+  if (descriptor.assign) {
+    ctx.setAssign(descriptor.assign);
+  }
+  ctx.signature.value = 1;
+  frame.view = ctx;
+  registerEvents(ctx);
+  if (ctx.getTemplate()) {
+    ctx.render();
+  } else {
+    ctx.endUpdate();
   }
-  /**
-   * Merge an array of mixin objects into the view prototype.
-   */
-  static mergeMixins(mixins, viewClass, makes) {
-    const proto = asRecord(viewClass.prototype);
-    const temp = {};
-    for (const node of mixins) {
-      for (const p in node) {
-        if (!hasOwnProperty(node, p)) continue;
-        const fn = node[p];
-        if (typeof fn !== "function") continue;
-        const mixinFn = fn;
-        const exist = temp[p];
-        if (p === "make") {
-          makes.push(mixinFn);
-          continue;
-        }
-        if (VIEW_EVENT_METHOD_REGEXP.test(p)) {
-          if (exist) {
-            temp[p] = _View.processMixinsSameEvent(mixinFn, exist);
-          } else {
-            mixinFn.marker = 1;
-            temp[p] = mixinFn;
-          }
-        } else if (!exist) {
-          temp[p] = mixinFn;
-        }
-      }
-    }
-    for (const p in temp) {
-      if (!hasOwnProperty(proto, p)) {
-        proto[p] = temp[p];
-      }
-    }
+  return ctx;
+}
+function unmountCtx(ctx) {
+  for (let i = ctx.cleanups.length - 1; i >= 0; i--) {
+    const cleanup = ctx.cleanups[i];
+    funcWithTry(cleanup, [], null, noop);
+  }
+  ctx.cleanups.length = 0;
+  unregisterEvents(ctx);
+  destroyAllResources(ctx, true);
+  if (ctx.signature.value > 0) {
+    ctx.fire("destroy", void 0, true, true);
+  }
+  EventDelegator.clearRangeEvents(ctx.id);
+  ctx.signature.value = 0;
+}
+
+// src/module-loader.ts
+var config = {
+  rootId: "root",
+  routeMode: "history",
+  hashbang: "#!",
+  error: (error) => {
+    throw error;
   }
-  /**
-   * Destroy a single resource entry.
-   */
-  static destroyResource(cache, key, callDestroy, oldEntity) {
-    const entry = cache[key];
-    if (!entry || entry.entity === oldEntity) return void 0;
-    const entity = entry.entity;
-    if (entity && typeof entity === "object") {
-      const destroyFn = entity["destroy"];
-      if (typeof destroyFn === "function" && callDestroy) {
-        funcWithTry(destroyFn, [], entity, noop);
+};
+function use(names, callback) {
+  const nameList = typeof names === "string" ? [names] : names;
+  const loadPromise = (() => {
+    if (config.require) {
+      const result = config.require(nameList);
+      if (result && typeof result.then === "function") {
+        return result;
       }
+      return Promise.resolve([]);
     }
-    Reflect.deleteProperty(cache, key);
-    return entity;
-  }
-  // ============================================================
-  // Static: extend and merge
-  // ============================================================
-  /**
-   * Extend View to create a new View subclass.
-   *
-   * Supports:
-   * - props.make: constructor-like init (called with initParams + {node, deep})
-   * - props.mixins: array of mixin objects
-   * - Event method patterns: `'name<click>'` etc.
-   */
-  static extend(props, statics) {
-    const definedProps = props ?? {};
-    const make = definedProps["make"];
-    const makes = [];
-    if (typeof make === "function") {
-      makes.push(make);
-    }
-    const ParentView = this;
-    const ChildView = class extends ParentView {
-      constructor(nodeId, ownerFrame, initParams, node, mixinCtors) {
-        super(nodeId, ownerFrame, initParams, node, []);
-        const instanceProps = this;
-        for (const key in definedProps) {
-          if (hasOwnProperty(definedProps, key) && key !== "make" && key !== "render") {
-            instanceProps[key] = definedProps[key];
-          }
-        }
-        this.id = nodeId;
-        this.owner = ownerFrame;
-        this.updater = new Updater(nodeId);
-        const params = [
-          initParams,
-          {
-            node,
-            deep: !this.template
+    return Promise.all(
+      nameList.map((name) => {
+        const importPath = name.startsWith(".") || name.startsWith("/") ? name : `./${name}`;
+        return import(
+          /* @vite-ignore */
+          /* webpackIgnore: true */
+          importPath
+        ).then((mod) => {
+          return mod && (mod["__esModule"] || // For Webpack
+          typeof mod["default"] === "function") ? mod["default"] : mod;
+        }).catch((err) => {
+          const errorHandler = config.error;
+          if (errorHandler) {
+            errorHandler(err instanceof Error ? err : new Error(String(err)));
           }
-        ];
-        const concatCtors = makes.concat(mixinCtors || []);
-        if (concatCtors.length) {
-          funcWithTry(concatCtors, params, this, noop);
-        }
-      }
-    };
-    for (const key in definedProps) {
-      if (hasOwnProperty(definedProps, key) && key !== "make") {
-        Reflect.set(ChildView.prototype, key, definedProps[key]);
-      }
-    }
-    if (statics) {
-      for (const key in statics) {
-        if (hasOwnProperty(statics, key)) {
-          Reflect.set(ChildView, key, statics[key]);
-        }
-      }
-    }
-    return ChildView;
-  }
-  /**
-   * Merge mixins into View prototype.
-   */
-  static merge(...mixins) {
-    const existingCtors = this.makes || [];
-    _View.mergeMixins(mixins, this, existingCtors);
-    return this;
+          return void 0;
+        });
+      })
+    );
+  })();
+  if (callback) {
+    loadPromise.then((modules) => {
+      callback(...modules);
+    });
   }
-  // ============================================================
-  // HMR support (static accept / dispose)
-  // ============================================================
-  /**
-   * Set up HMR accept handler for this view module.
-   *
-   * When the module is hot-replaced, the new View class is extracted from
-   * the new module, registered in the view registry, and all currently
-   * mounted frames using this viewPath are re-mounted.
-   *
-   * No-op when `hot` is undefined (production / non-HMR environment).
-   *
-   * ```ts
-   * if (import.meta.hot) {
-   *   HomeView.accept(import.meta.hot, 'home');
-   * }
-   * ```
-   */
-  static accept(hot, viewPath) {
-    if (!hot) return;
-    acceptView(hot, viewPath);
+  return loadPromise;
+}
+
+// src/view-registry.ts
+var viewSetupRegistry = {};
+function getViewClass(path) {
+  return viewSetupRegistry[path];
+}
+function registerViewClass(viewPath, setup) {
+  const parsed = parseUri(viewPath);
+  const path = parsed.path;
+  if (path) {
+    viewSetupRegistry[path] = setup;
   }
-  /**
-   * Set up HMR dispose handler for this view module.
-   *
-   * When the module is about to be replaced, the old View class is removed
-   * from the registry so subsequent lookups don't return the stale class.
-   *
-   * No-op when `hot` is undefined (production / non-HMR environment).
-   *
-   * ```ts
-   * if (import.meta.hot) {
-   *   HomeView.dispose(import.meta.hot, 'home');
-   * }
-   * ```
-   */
-  static dispose(hot, viewPath) {
-    if (!hot) return;
-    disposeView(hot, viewPath);
+}
+function invalidateViewClass(viewPath) {
+  const parsed = parseUri(viewPath);
+  const path = parsed.path;
+  if (path) {
+    Reflect.deleteProperty(viewSetupRegistry, path);
   }
-};
-function defineView(props, statics) {
-  return View.extend(props, statics);
+}
+function getViewClassRegistry() {
+  return viewSetupRegistry;
 }
 
 // src/frame.ts
+var frameRegistry = /* @__PURE__ */ new Map();
 var rootFrame;
 var globalAlter;
-var MAX_FRAME_POOL = 64;
-var frameCache = [];
-var staticEmitter = new EventEmitter();
-var Frame = class _Frame extends EventEmitter {
-  /** Frame ID (same as owner DOM element ID) */
-  id;
-  /** Parent Frame ID */
-  _parentId = void 0;
-  get parentId() {
-    return this._parentId;
-  }
-  /** Children map: id -> id */
-  childrenMap = {};
-  /** Children count */
-  childrenCount = 0;
-  /** Ready count (children that have fired 'created') */
-  readyCount = 0;
-  /** Set of child frame IDs that have fired 'created' */
-  readyMap = /* @__PURE__ */ new Set();
-  /** View instance */
-  viewInstance;
-  /** Get view instance (read-only) */
-  get view() {
-    return this.viewInstance;
-  }
-  /** Invoke list for deferred method calls */
-  invokeList = [];
-  /** Signature for async operation tracking */
-  signature = 1;
-  /** Whether view has altered */
-  hasAltered = 0;
-  /** Whether view is destroyed */
-  destroyed = 0;
-  /** View path (v-lark attribute value) */
-  viewPath;
-  /** Original template before mount */
-  originalTemplate;
-  /** Hold fire created flag */
-  holdFireCreated = 0;
-  /** Children created flag */
-  childrenCreated = 0;
-  /** Children alter flag */
-  childrenAlter = 0;
-  constructor(id, parentId) {
-    super();
-    this.id = id;
-    if (parentId) {
-      this._parentId = parentId;
-    }
-    registerFrame(id, this);
-    const element = document.getElementById(id);
-    if (element) {
-      element.frame = this;
-      element.frameBound = 1;
-    }
-    _Frame.fire("add", { frame: this });
-  }
-  // ============================================================
-  // Instance methods
-  // ============================================================
-  /**
-   * 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, viewInitParams) {
-    const node = document.getElementById(this.id);
-    const pId = this.parentId;
-    if (!this.hasAltered && node) {
-      this.hasAltered = 1;
-      this.originalTemplate = node.innerHTML;
-    }
-    this.unmountView();
-    this.destroyed = 0;
-    const parsed = parseUri(viewPath || "");
-    const viewClassName = parsed.path;
-    if (!node || !viewClassName) return;
-    this.viewPath = viewPath;
-    const params = parsed["params"];
-    translateQuery(pId || this.id, viewPath, params);
-    const initParams = { ...params };
-    if (viewInitParams) {
-      assign(initParams, viewInitParams);
-    }
-    const sign = this.signature;
-    const registered = getViewClass(viewClassName);
-    if (registered) {
-      this.doMountView(registered, initParams, node, sign);
-      return;
-    }
-    use(viewClassName, (ViewClass) => {
-      if (sign !== this.signature) return;
-      if (typeof ViewClass === "function") {
-        const ViewClassTyped = ViewClass;
-        registerViewClass(viewClassName, ViewClassTyped);
-        this.doMountView(ViewClassTyped, initParams, node, sign);
-      } else {
-        const error = new Error(`Cannot load view: ${viewClassName}`);
-        const errorHandler = config.error;
-        if (errorHandler) {
-          errorHandler(error);
-        }
+var staticEmitter = createEmitter();
+function isViewSetup(fn) {
+  return typeof fn === "function";
+}
+function createFrame(id, parentId) {
+  const emitter3 = createEmitter();
+  const invokeList = [];
+  const childrenMap = {};
+  const readyMap = /* @__PURE__ */ new Set();
+  let viewPath;
+  function getViewPath() {
+    return viewPath;
+  }
+  const frame = {
+    id,
+    getViewPath,
+    parentId,
+    view: void 0,
+    invokeList,
+    signature: 1,
+    destroyed: 0,
+    hasAltered: 0,
+    originalTemplate: void 0,
+    holdFireCreated: 0,
+    childrenCreated: 0,
+    childrenAlter: 0,
+    childrenMap,
+    childrenCount: 0,
+    readyCount: 0,
+    readyMap,
+    emitter: emitter3,
+    mountView(viewPathArg, viewInitParams) {
+      const node = document.getElementById(frame.id);
+      const pId = frame.parentId;
+      if (!frame.hasAltered && node) {
+        frame.hasAltered = 1;
+        frame.originalTemplate = node.innerHTML;
       }
-    });
-  }
-  /**
-   * Internal: actually mount the view after class is loaded.
-   */
-  doMountView(ViewClass, params, node, sign) {
-    if (sign !== this.signature) return;
-    const mixinConstructors = View.prepare(ViewClass);
-    const Constructor = ViewClass;
-    const view = new Constructor(
-      this.id,
-      this,
-      params,
-      node,
-      mixinConstructors
-    );
-    this.viewInstance = view;
-    view.signature = 1;
-    View.delegateEvents(view);
-    const initResult = funcWithTry(
-      view.init,
-      [params, { node, deep: !view.template }],
-      view,
-      noop
-    );
-    const nextSign = ++this.signature;
-    Promise.resolve(initResult).then(() => {
-      if (nextSign !== this.signature) return;
-      if (view.template) {
-        view.render();
-      } else {
-        this.hasAltered = 0;
-        if (!view.endUpdatePendingFlag) {
-          view.endUpdate();
+      frame.unmountView();
+      frame.destroyed = 0;
+      const parsed = parseUri(viewPathArg || "");
+      const viewClassName = parsed.path;
+      if (!node || !viewClassName) return;
+      viewPath = viewPathArg;
+      const params = parsed.params;
+      translateQuery(pId ?? frame.id, viewPathArg, params);
+      const initParams = { ...params };
+      if (viewInitParams) {
+        assign(initParams, viewInitParams);
+      }
+      const sign = frame.signature;
+      const registered = getViewClass(viewClassName);
+      if (registered) {
+        doMountView(registered, initParams, node, sign);
+        return;
+      }
+      use(viewClassName, (loadedModule) => {
+        if (sign !== frame.signature) return;
+        if (isViewSetup(loadedModule)) {
+          registerViewClass(viewClassName, loadedModule);
+          doMountView(loadedModule, initParams, node, sign);
+        } else {
+          const error = new Error(`Cannot load view: ${viewClassName}`);
+          const errorHandler = config.error;
+          if (errorHandler) {
+            errorHandler(error);
+          }
         }
+      });
+    },
+    unmountView() {
+      const currentView = frame.view;
+      frame.invokeList.length = 0;
+      if (!currentView) return;
+      if (!globalAlter) {
+        globalAlter = { id: frame.id };
       }
-    });
-  }
-  /**
-   * Unmount current view.
-   */
-  unmountView() {
-    const view = this.view;
-    this.invokeList = [];
-    if (!view) return;
-    if (!globalAlter) {
-      globalAlter = { id: this.id };
-    }
-    this.destroyed = 1;
-    this.unmountZone();
-    notifyAlter(this, globalAlter);
-    if (view.signature > 0) {
-      view.fire("destroy", void 0, true, true);
-    }
-    EventDelegator.clearRangeEvents(this.id);
-    delete this["viewInstance"];
-    const node = document.getElementById(this.id);
-    if (node && this.originalTemplate) {
-      node.innerHTML = this.originalTemplate;
-    }
-    globalAlter = void 0;
-    unmark(view);
-  }
-  /**
-   * Mount a child frame.
-   */
-  mountFrame(frameId, viewPath, viewInitParams) {
-    notifyAlter(this, { id: frameId });
-    let childFrame = getFrame(frameId);
-    if (!childFrame) {
-      if (!this.childrenMap[frameId]) {
-        this.childrenCount++;
+      frame.destroyed = 1;
+      frame.unmountZone();
+      notifyAlter(frame, globalAlter);
+      unmountCtx(currentView);
+      frame.view = void 0;
+      const node = document.getElementById(frame.id);
+      if (node && frame.originalTemplate) {
+        node.innerHTML = frame.originalTemplate;
       }
-      this.childrenMap[frameId] = frameId;
-      childFrame = frameCache.pop();
-      if (childFrame) {
-        reInitFrame(childFrame, frameId, this.id);
-      } else {
-        childFrame = new _Frame(frameId, this.id);
+      globalAlter = void 0;
+      unmark(currentView);
+    },
+    mountFrame(frameId, viewPathArg, viewInitParams) {
+      notifyAlter(frame, { id: frameId });
+      let childFrame = frameRegistry.get(frameId);
+      if (!childFrame) {
+        if (!frame.childrenMap[frameId]) {
+          frame.childrenCount++;
+        }
+        frame.childrenMap[frameId] = frameId;
+        childFrame = createFrame(frameId, frame.id);
       }
-    }
-    childFrame.mountView(viewPath, viewInitParams);
-    return childFrame;
-  }
-  /**
-   * Unmount a child frame.
-   */
-  unmountFrame(id) {
-    const targetId = id ? this.childrenMap[id] : this.id;
-    const frame = getFrame(targetId);
-    if (!frame) return;
-    const wasCreated = frame.readyCount > 0;
-    const pId = frame.parentId;
-    frame.unmountView();
-    removeFrame2(targetId, wasCreated);
-    reInitFrameForCache(frame);
-    if (frameCache.length < MAX_FRAME_POOL) {
-      frameCache.push(frame);
-    }
-    const parent = getFrame(pId || "");
-    if (parent && parent.childrenMap[targetId]) {
-      Reflect.deleteProperty(parent.childrenMap, targetId);
-      parent.childrenCount--;
-      notifyCreated(parent);
-    }
-  }
-  /**
-   * Mount all views in a zone.
-   */
-  mountZone(zoneId) {
-    const targetZone = zoneId || this.id;
-    this.holdFireCreated = 1;
-    const rootEl = document.getElementById(targetZone);
-    if (!rootEl) return;
-    const viewElements = rootEl.querySelectorAll(`[${LARK_VIEW}]`);
-    const frames = [];
-    viewElements.forEach((el) => {
-      if (!(el instanceof HTMLElement)) return;
-      if (htmlElIsBound(el)) return;
-      const elId = ensureElementId(el, "frame_");
-      el.frameBound = 1;
-      const viewPath = getAttribute(el, LARK_VIEW);
-      frames.push([elId, viewPath]);
-    });
-    for (const [frameId, viewPath] of frames) {
-      this.mountFrame(frameId, viewPath);
-    }
-    this.holdFireCreated = 0;
-    notifyCreated(this);
-  }
-  /**
-   * Unmount all views in a zone.
-   */
-  unmountZone(zoneId) {
-    for (const childId in this.childrenMap) {
-      if (hasOwnProperty(this.childrenMap, childId)) {
-        if (!zoneId || childId !== zoneId) {
-          this.unmountFrame(childId);
+      childFrame.mountView(viewPathArg, viewInitParams);
+      return childFrame;
+    },
+    unmountFrame(id2) {
+      const targetId = id2 ? frame.childrenMap[id2] : frame.id;
+      const targetFrame = frameRegistry.get(targetId);
+      if (!targetFrame) return;
+      const wasCreated = targetFrame.readyCount > 0;
+      const pId = targetFrame.parentId;
+      targetFrame.unmountView();
+      removeFrame(targetId, wasCreated);
+      const parent = frameRegistry.get(pId ?? "");
+      if (parent && parent.childrenMap[targetId]) {
+        Reflect.deleteProperty(parent.childrenMap, targetId);
+        parent.childrenCount--;
+        notifyCreated(parent);
+      }
+    },
+    mountZone(zoneId) {
+      const targetZone = zoneId ?? frame.id;
+      frame.holdFireCreated = 1;
+      const rootEl = document.getElementById(targetZone);
+      if (!rootEl) return;
+      const viewElements = rootEl.querySelectorAll(`[${LARK_VIEW}]`);
+      const frames = [];
+      viewElements.forEach((el) => {
+        if (!(el instanceof HTMLElement)) return;
+        if (htmlElIsBound(el)) return;
+        const elId = ensureElementId(el, "frame_");
+        Reflect.set(el, "frameBound", 1);
+        const viewPathArg = getAttribute(el, LARK_VIEW);
+        if (viewPathArg) {
+          frames.push([elId, viewPathArg]);
         }
+      });
+      for (const [frameId, viewPathArg] of frames) {
+        frame.mountFrame(frameId, viewPathArg);
       }
-    }
-    notifyCreated(this);
-  }
-  /**
-   * Get all child frame IDs.
-   */
-  children() {
-    const result = [];
-    for (const id in this.childrenMap) {
-      if (hasOwnProperty(this.childrenMap, id)) {
-        result.push(id);
+      frame.holdFireCreated = 0;
+      notifyCreated(frame);
+    },
+    unmountZone(zoneId) {
+      for (const childId in frame.childrenMap) {
+        if (hasOwnProperty(frame.childrenMap, childId)) {
+          if (!zoneId || childId !== zoneId) {
+            frame.unmountFrame(childId);
+          }
+        }
       }
-    }
-    return result;
-  }
-  /**
-   * Get parent frame at given level.
-   * @param level - How many levels up (default 1)
-   */
-  parent(level = 1) {
-    let frame = void 0;
-    let currentPid = this.parentId;
-    let n = level >>> 0 || 1;
-    while (currentPid && n--) {
-      frame = getFrame(currentPid);
-      currentPid = frame?.parentId;
-    }
-    return frame;
-  }
-  /**
-   * Invoke a method on the view.
-   */
-  invoke(name, args) {
-    let result;
-    const view = this.view;
-    if (view && view.rendered) {
-      const fn = Reflect.get(view, name);
-      if (typeof fn === "function") {
-        result = funcWithTry(fn, args || [], view, noop);
+      notifyCreated(frame);
+    },
+    parent(level = 1) {
+      let result = void 0;
+      let currentPid = frame.parentId;
+      let n = level >>> 0 || 1;
+      while (currentPid && n--) {
+        result = frameRegistry.get(currentPid);
+        currentPid = result?.parentId;
       }
-    } else {
-      const key = SPLITTER + name;
-      let existingEntry;
-      for (const entry of this.invokeList) {
-        if (entry.key === key) {
-          existingEntry = entry;
-          break;
+      return result;
+    },
+    invoke(name, args) {
+      let result;
+      const currentView = frame.view;
+      if (currentView && currentView.rendered.value) {
+        const fn = Reflect.get(currentView, name);
+        if (typeof fn === "function") {
+          result = funcWithTry(fn, args ?? [], currentView, noop);
         }
+      } else {
+        const key = SPLITTER + name;
+        let existingEntry;
+        for (const entry of frame.invokeList) {
+          if (entry.key === key) {
+            existingEntry = entry;
+            break;
+          }
+        }
+        if (existingEntry) {
+          existingEntry.removed = args === existingEntry.args;
+        }
+        const newEntry = {
+          name,
+          args: args ?? [],
+          key
+        };
+        frame.invokeList.push(newEntry);
       }
-      if (existingEntry) {
-        existingEntry.removed = args === existingEntry.args;
+      return result;
+    },
+    children() {
+      const result = [];
+      for (const id2 in frame.childrenMap) {
+        if (hasOwnProperty(frame.childrenMap, id2)) {
+          result.push(id2);
+        }
       }
-      const newEntry = {
-        name,
-        args: args || [],
-        key
-      };
-      this.invokeList.push(newEntry);
+      return result;
+    },
+    on(event, handler) {
+      emitter3.on(event, handler);
+      return frame;
+    },
+    off(event, handler) {
+      emitter3.off(event, handler);
+      return frame;
+    },
+    fire(event, data) {
+      emitter3.fire(event, data);
+      return frame;
     }
-    return result;
-  }
-  /**
-   * 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(name, args) {
-    return this.invoke(name, args);
+  };
+  frameRegistry.set(id, frame);
+  const element = document.getElementById(id);
+  if (element) {
+    Reflect.set(element, "frame", frame);
+    Reflect.set(element, "frameBound", 1);
   }
-  // ============================================================
-  // Static methods
-  // ============================================================
+  staticEmitter.fire("add", { frame });
+  return frame;
+}
+function doMountView(setup, params, node, sign) {
+  const frameId = node.id;
+  const frame = frameRegistry.get(frameId);
+  if (!frame) return;
+  if (sign !== frame.signature) return;
+  const ctx = mountCtx(frame, setup, params);
+  frame.view = ctx;
+  runInvokes(frame);
+}
+var Frame = {
   /** Get frame by ID */
-  static get(id) {
-    return getFrame(id);
-  }
+  get(id) {
+    return frameRegistry.get(id);
+  },
   /** Get all frames */
-  static getAll() {
-    return getAllFrames();
-  }
+  getAll() {
+    return frameRegistry;
+  },
   /**
-   * 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.
+   * Returns the existing root frame, or undefined if none has been created.
    */
-  static getRoot() {
+  getRoot() {
     return rootFrame;
-  }
+  },
   /**
-   * 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.
+   * Create (or return) the singleton root frame.
+   * Idempotent: subsequent calls always return the original root.
    */
-  static createRoot(rootId) {
+  createRoot(rootId) {
     if (!rootFrame) {
-      rootId = rootId || "root";
-      let rootElement = document.getElementById(rootId);
+      const id = rootId ?? "root";
+      let rootElement = document.getElementById(id);
       if (!rootElement) {
         rootElement = document.body;
-        rootElement.id = rootId;
+        rootElement.id = id;
       }
-      rootFrame = new _Frame(rootId);
+      rootFrame = createFrame(id);
     }
     return rootFrame;
-  }
+  },
   /** Bind event listener (static) */
-  static on(event, handler) {
+  on(event, handler) {
     staticEmitter.on(event, handler);
-    return _Frame;
-  }
+    return Frame;
+  },
   /** Unbind event listener (static) */
-  static off(event, handler) {
+  off(event, handler) {
     staticEmitter.off(event, handler);
-    return _Frame;
-  }
+    return Frame;
+  },
   /** Fire event (static) */
-  static fire(event, data) {
+  fire(event, data) {
     staticEmitter.fire(event, data);
   }
 };
 function htmlElIsBound(element) {
-  return !!element.frameBound;
+  return !!Reflect.get(element, "frameBound");
 }
-function removeFrame2(id, wasCreated) {
-  const frameInstance = getFrame(id);
+function removeFrame(id, wasCreated) {
+  const frameInstance = frameRegistry.get(id);
   if (!frameInstance) return;
-  removeFrame(id);
-  Frame.fire("remove", { frame: frameInstance, fcc: wasCreated });
+  frameRegistry.delete(id);
+  staticEmitter.fire("remove", { frame: frameInstance, fcc: wasCreated });
   const element = document.getElementById(id);
   if (element) {
-    element.frameBound = 0;
+    Reflect.set(element, "frameBound", 0);
     Reflect.deleteProperty(element, "frame");
   }
 }
 function notifyCreated(frameInstance) {
-  if (!frameInstance["childrenCreated"] && !frameInstance["holdFireCreated"] && frameInstance["childrenCount"] === frameInstance["readyCount"]) {
-    if (!frameInstance["childrenCreated"]) {
-      frameInstance["childrenCreated"] = 1;
-      frameInstance["childrenAlter"] = 0;
-      frameInstance.fire("created");
-    }
+  if (!frameInstance.childrenCreated && !frameInstance.holdFireCreated && frameInstance.childrenCount === frameInstance.readyCount) {
+    frameInstance.childrenCreated = 1;
+    frameInstance.childrenAlter = 0;
+    frameInstance.emitter.fire("created");
     const pId = frameInstance.parentId;
     if (pId) {
-      const parent = getFrame(pId);
+      const parent = frameRegistry.get(pId);
       if (parent && !parent.readyMap.has(frameInstance.id)) {
         parent.readyMap.add(frameInstance.id);
         parent.readyCount++;
@@ -3548,13 +3136,13 @@ function notifyCreated(frameInstance) {
   }
 }
 function notifyAlter(frameInstance, data) {
-  if (!frameInstance["childrenAlter"] && frameInstance["childrenCreated"]) {
-    frameInstance["childrenCreated"] = 0;
-    frameInstance["childrenAlter"] = 1;
-    frameInstance.fire("alter", data);
+  if (!frameInstance.childrenAlter && frameInstance.childrenCreated) {
+    frameInstance.childrenCreated = 0;
+    frameInstance.childrenAlter = 1;
+    frameInstance.emitter.fire("alter", data);
     const pId = frameInstance.parentId;
     if (pId) {
-      const parent = getFrame(pId);
+      const parent = frameRegistry.get(pId);
       if (parent && parent.readyMap.has(frameInstance.id)) {
         parent.readyCount--;
         parent.readyMap.delete(frameInstance.id);
@@ -3563,483 +3151,310 @@ function notifyAlter(frameInstance, data) {
     }
   }
 }
-function reInitFrame(frame, id, parentId) {
-  Reflect.set(frame, "id", id);
-  frame["_parentId"] = parentId;
-  frame["childrenMap"] = {};
-  frame["childrenCount"] = 0;
-  frame["readyCount"] = 0;
-  frame["signature"] = 1;
-  frame["readyMap"] = /* @__PURE__ */ new Set();
-  frame["invokeList"] = [];
-  registerFrame(id, frame);
-}
-function reInitFrameForCache(frame) {
-  Reflect.set(frame, "id", "");
-  frame["_parentId"] = void 0;
-  frame["childrenMap"] = {};
-  frame["readyMap"] = /* @__PURE__ */ new Set();
-}
 function translateQuery(pId, src, params) {
-  const parentFrame = getFrame(pId);
+  const parentFrame = frameRegistry.get(pId);
   const parentView = parentFrame?.view;
   if (!parentView) return;
   const parentRefData = parentView.updater.refData;
   if (!parentRefData) return;
   if (src.indexOf(SPLITTER) > 0) {
     translateData(parentRefData, params);
-    const paramsRec = params;
-    const splitterValue = paramsRec[SPLITTER];
-    if (splitterValue && typeof splitterValue === "object") {
-      assign(params, splitterValue);
+    const splitterValue = Reflect.get(params, SPLITTER);
+    if (isRecord(splitterValue)) {
+      for (const k in splitterValue) {
+        if (hasOwnProperty(splitterValue, k)) {
+          const v = splitterValue[k];
+          if (typeof v === "string") {
+            params[k] = v;
+          }
+        }
+      }
       Reflect.deleteProperty(params, SPLITTER);
     }
   }
 }
 
 // src/cross-site.ts
-var preparePromises = {};
-var projectsMap = null;
-function loadRemoteView(viewPath, bizCode) {
-  const crossConfigs = config.crossConfigs || window.crossConfigs;
-  const currentName = config.projectName || "";
-  const slashIndex = viewPath.indexOf("/");
-  const projectName = slashIndex > -1 ? viewPath.substring(0, slashIndex) : viewPath;
-  if (projectName === currentName) return Promise.resolve();
-  if (!preparePromises[projectName]) {
-    if (!projectsMap) {
-      const map = toMap(crossConfigs || [], "projectName");
-      projectsMap = map;
-    }
-    const info = projectsMap[projectName];
-    if (!info) {
-      return Promise.reject(
-        new Error(`Cannot find ${projectName} from crossConfigs`)
-      );
-    }
-    preparePromises[projectName] = use(`${projectName}/prepare`).then((modules) => {
-      let mod = modules[0];
-      if (mod && typeof mod === "object" && mod !== null) {
-        const rec = mod;
-        if (rec["__esModule"]) {
-          mod = rec["default"];
-        }
-      }
-      if (typeof mod === "function") {
-        return mod({ bizCode });
-      }
-      return void 0;
-    }).catch((err) => {
-      Reflect.deleteProperty(preparePromises, projectName);
-      throw err;
-    });
-  }
-  return preparePromises[projectName];
-}
+var projectsMap = /* @__PURE__ */ new Map();
 function resetProjectsMap() {
-  projectsMap = null;
+  projectsMap.clear();
 }
-var skeletonTemplate = (data, viewId) => {
-  let skeletonHtml = "<div>Loading...</div>";
-  if (data && typeof data === "object") {
-    const candidate = data.skeleton;
-    if (typeof candidate === "string") skeletonHtml = candidate;
+function getProject(projectName) {
+  return projectsMap.get(projectName);
+}
+if (typeof config !== "undefined" && config.crossSites) {
+  for (const cs of config.crossSites) {
+    projectsMap.set(cs.projectName, cs);
   }
-  return `<div id="mf_${viewId}">${skeletonHtml}</div>`;
-};
-var CrossSite = View.extend({
-  /** Skeleton template renders loading state + child container */
-  template: skeletonTemplate,
-  init(params) {
-    this.$sign = 0;
-    this.on("destroy", () => {
-      this.$sign = -1;
-    });
-    this.assign?.(params);
-  },
-  assign(data) {
-    this.$view = typeof data["view"] === "string" ? data["view"] : "";
-    const nested = data["params"];
-    const nestedParams = nested && typeof nested === "object" ? nested : {};
-    this.$params = { ...data, ...nestedParams };
-    this.updater.set({
-      skeleton: data["skeleton"],
-      skeletonParams: data["skeletonParams"] || {},
-      bizCode: data["bizCode"]
-    });
-    if (this.$sign > 0) {
-      this.updateView();
-    }
-    return false;
-  },
-  async updateView() {
-    const sign = ++this.$sign;
-    const stored = this.updater.get();
-    const bizCode = stored.bizCode;
-    try {
-      await loadRemoteView(this.$view, bizCode);
-    } catch (ex) {
-      const node = document.getElementById("mf_" + this.id);
-      if (node) {
-        const err = ex instanceof Error ? ex : new Error(String(ex));
-        node.innerHTML = err.message || String(err);
-      }
-    }
-    if (this.$sign !== sign) return;
-    const mf = Frame.get("mf_" + this.id);
-    const parsedNew = parseUri(this.$view);
-    const newPath = parsedNew.path;
-    const oldPath = mf?.viewPath ? parseUri(mf.viewPath).path : "";
-    const view = mf?.view;
-    if (newPath === oldPath && view && typeof view.assign === "function") {
-      const result = funcWithTry(view.assign, [this.$params], view, noop);
-      if (result) {
-        view.render();
-      }
-      return;
-    }
-    const owner = this.owner;
-    if (owner && typeof owner !== "number") {
-      owner.mountFrame("mf_" + this.id, this.$view, this.$params);
-    }
-  },
-  render() {
-    const params = this.$params;
-    this.updater.digest({
-      skeleton: params?.["skeleton"]
+}
+var CrossSite = (ctx, params) => {
+  const p = params ?? {};
+  const viewPath = p["view"] ?? "";
+  const bizCode = p["bizCode"] ?? "";
+  const skeleton = p["skeleton"] ?? "Loading\u2026";
+  const state = {
+    sign: 0,
+    mounted: false,
+    lastViewPath: void 0
+  };
+  const parsed = parseUri(viewPath);
+  const parts = parsed.path.split("/");
+  const projectName = parts[0] ?? "";
+  const remotePath = parts.slice(1).join("/");
+  const projectConfig = getProject(projectName);
+  const currentSign = ++state.sign;
+  if (projectConfig && remotePath) {
+    use(`${projectName}/prepare`, () => {
+      if (currentSign !== state.sign) return;
+      use(viewPath, () => {
+        if (currentSign !== state.sign) return;
+        const frameId = `mf_${ctx.id}`;
+        ctx.owner.mountFrame(frameId, viewPath, {
+          bizCode,
+          project: projectName
+        });
+        state.mounted = true;
+        state.lastViewPath = viewPath;
+        ctx.updater.set({ _csLoaded: true }).digest();
+      });
     });
-    this.updateView();
-  },
-  /**
-   * Invoke a method on the remote view.
-   * Usage: mf.invoke('callView', methodName, ...args)
-   */
-  callView(name, ...args) {
-    const mf = Frame.get("mf_" + this.id);
-    return mf?.invoke(name, args);
-  }
-});
-var cross_site_default = CrossSite;
-
-// src/service.ts
-var Payload = class {
-  /** Payload data */
-  data;
-  /** Internal cache info */
-  cacheInfo;
-  constructor(data = {}) {
-    this.data = data;
-  }
-  /** Get a value from payload data */
-  get(key) {
-    return this.data[key];
-  }
-  /** Set a value in payload data */
-  set(keyOrData, value) {
-    if (typeof keyOrData === "string") {
-      this.data[keyOrData] = value;
-    } else {
-      assign(this.data, keyOrData);
-    }
-    return this;
   }
-};
-var FETCH_FLAGS_ALL = 1;
-var FETCH_FLAGS_ONE = 2;
-var Service = class {
-  /** Service instance ID */
-  id = "";
-  /** Whether service is busy (1 = busy) */
-  busy = 0;
-  /** Whether service is destroyed (1 = destroyed) */
-  destroyed = 0;
-  /** Task queue for sequential operations */
-  taskQueue = [];
-  /** Previous dequeue arguments */
-  prevArgs = [];
-  /** Instance event emitter */
-  _emitter = new EventEmitter();
-  constructor() {
-    this.id = generateId("service");
-  }
-  // ============================================================
-  // Instance accessors for type-level data
-  // ============================================================
-  /** Instance event emitter (public accessor) */
-  get emitter() {
-    return this._emitter;
-  }
-  /**
-   * Get internals object for serviceSend compatibility.
-   * References per-type static state from the current class.
-   */
-  get internals() {
-    const constructor = this.constructor;
-    return {
-      metaList: constructor._metaList,
-      payloadCache: constructor._payloadCache,
-      pendingCacheKeys: constructor._pendingCacheKeys,
-      syncFn: constructor._syncFn,
-      staticEmitter: constructor._staticEmitter
-    };
-  }
-  /**
-   * Get type reference (the constructor) for serviceSend compatibility.
-   * Static methods like get/create are accessible via the constructor.
-   */
-  get type() {
-    return this.constructor;
-  }
-  // ============================================================
-  // Instance methods
-  // ============================================================
-  /**
-   * Fetch all endpoints, callback when all complete.
-   * Uses cache when available.
-   */
-  all(attrs, done) {
-    serviceSend(this, attrs, done, FETCH_FLAGS_ALL, false);
-    return this;
-  }
-  /**
-   * Fetch all endpoints, callback on each completion.
-   */
-  one(attrs, done) {
-    serviceSend(this, attrs, done, FETCH_FLAGS_ONE, false);
-    return this;
-  }
-  /**
-   * Fetch all endpoints, skip cache (always request).
-   */
-  save(attrs, done) {
-    serviceSend(this, attrs, done, FETCH_FLAGS_ALL, true);
-    return this;
-  }
-  /**
-   * Enqueue a task for sequential execution.
-   */
-  enqueue(callback) {
-    if (!this.destroyed) {
-      this.taskQueue.push(callback);
-      this.dequeue(...this.prevArgs);
-    }
-    return this;
-  }
-  /**
-   * Dequeue and execute the next task in queue.
-   */
-  dequeue(...args) {
-    if (!this.busy && !this.destroyed) {
-      this.busy = 1;
-      setTimeout(() => {
-        this.busy = 0;
-        if (!this.destroyed) {
-          const task2 = this.taskQueue.shift();
-          if (task2) {
-            this.prevArgs = args;
-            funcWithTry(task2, args, this, noop);
-          }
-        }
-      }, 0);
+  ctx.on("destroy", () => {
+    state.sign++;
+    state.mounted = false;
+    state.lastViewPath = void 0;
+  });
+  const renderSkeleton = () => {
+    if (state.mounted) {
+      return '<div class="lark-cs-container" style="display:none"></div>';
     }
+    return `<div class="lark-cs-skeleton" data-lark-cs-skeleton="1">${skeleton}</div>`;
+  };
+  return {
+    template: renderSkeleton,
+    events: {}
+  };
+};
+var cross_site_default = CrossSite;
+
+// src/service.ts
+function isPayload(v) {
+  if (v == null || typeof v !== "object") return false;
+  return "data" in v && "get" in v;
+}
+function isServiceMetaEntry(v) {
+  if (v == null || typeof v !== "object") return false;
+  return "name" in v && "url" in v;
+}
+function createPayload(data = {}) {
+  const payloadData = data;
+  function get(key) {
+    return payloadData[key];
   }
-  /**
-   * Destroy the service instance.
-   * After destruction, no new requests can be sent.
-   */
-  destroy() {
-    this.destroyed = 1;
-    this.taskQueue = [];
-  }
-  // Instance event methods (delegate to instance emitter)
-  on(event, handler) {
-    this._emitter.on(event, handler);
-    return this;
-  }
-  off(event, handler) {
-    this._emitter.off(event, handler);
-    return this;
-  }
-  fire(event, data) {
-    this._emitter.fire(event, data);
-    return this;
+  function set(keyOrData, value) {
+    if (typeof keyOrData === "string") {
+      payloadData[keyOrData] = value;
+    } else {
+      assign(payloadData, keyOrData);
+    }
+    return api;
   }
-  // ============================================================
-  // Per-type static state
-  // ============================================================
-  /** Per-type metadata registry */
-  static _metaList = {};
-  /** Per-type payload cache (LFU with frequency eviction) */
-  static _payloadCache = new Cache({
-    maxSize: 20,
-    bufferSize: 5
+  const api = { data: payloadData, get, set };
+  return api;
+}
+var FETCH_FLAGS_ALL = 1;
+var FETCH_FLAGS_ONE = 2;
+function createService(syncFn, cacheMax = 20, cacheBuffer = 5) {
+  const metaList = {};
+  const payloadCache = createCache({
+    maxSize: cacheMax,
+    bufferSize: cacheBuffer
   });
-  /** Per-type pending cache keys for deduplication */
-  static _pendingCacheKeys = {};
-  /** Per-type sync function */
-  static _syncFn = noop;
-  /** Per-type static event emitter */
-  static _staticEmitter = new EventEmitter();
-  /** Per-type cache max size */
-  static _cacheMax = 20;
-  /** Per-type cache buffer size */
-  static _cacheBuffer = 5;
-  // ============================================================
-  // Static methods (operate on per-type state via `this`)
-  // ============================================================
-  /**
-   * Register API endpoint metadata.
-   */
-  static add(attrs) {
+  const pendingCacheKeys = {};
+  const staticEmitter2 = createEmitter();
+  const internals = {
+    metaList,
+    payloadCache,
+    pendingCacheKeys,
+    syncFn,
+    staticEmitter: staticEmitter2
+  };
+  function add(attrs) {
     if (!Array.isArray(attrs)) {
       attrs = [attrs];
     }
-    for (const payload of attrs) {
-      if (payload) {
-        const name = payload.name;
-        const cache = payload.cache;
-        payload.cache = cache ? cache | 0 : 0;
-        this._metaList[name] = payload;
+    for (const entry of attrs) {
+      if (entry) {
+        const name = entry.name;
+        const cache = entry.cache;
+        entry.cache = cache ? cache | 0 : 0;
+        metaList[name] = entry;
       }
     }
   }
-  /**
-   * Get metadata for an API endpoint.
-   */
-  static meta(attrs) {
+  function meta(attrs) {
     const name = typeof attrs === "string" ? attrs : String(attrs["name"] ?? "");
-    const known = this._metaList[name];
+    const known = metaList[name];
     if (known) return known;
-    return attrs;
+    if (isServiceMetaEntry(attrs)) {
+      return attrs;
+    }
+    return { name, url: "" };
   }
-  /**
-   * Create a Payload for an API request.
-   */
-  static create(attrs) {
-    const meta = this.meta(attrs);
-    const cache = toCacheValue(attrs["cache"]) || meta.cache || 0;
-    const entity = new Payload();
-    entity.set(meta);
+  function create(attrs) {
+    const m = meta(attrs);
+    const cache = toCacheValue(attrs["cache"]) || m.cache || 0;
+    const entity = createPayload();
+    entity.set(m);
     entity.cacheInfo = {
-      name: meta.name,
-      after: typeof meta.after === "function" ? meta.after : void 0,
-      cleans: typeof meta.cleanKeys === "string" ? meta.cleanKeys : void 0,
-      key: cache ? defaultCacheKey(meta, attrs) : "",
+      name: m.name,
+      after: typeof m.after === "function" ? m.after : void 0,
+      cleans: typeof m.cleanKeys === "string" ? m.cleanKeys : void 0,
+      key: cache ? defaultCacheKey(m, attrs) : "",
       time: 0
     };
     if (attrs !== null) {
       entity.set(attrs);
     }
-    const before = meta.before;
+    const before = m.before;
     if (typeof before === "function") {
       funcWithTry(before, [entity], entity, noop);
     }
-    this._staticEmitter.fire("begin", { payload: entity });
+    staticEmitter2.fire("begin", { payload: entity });
     return entity;
   }
-  /**
-   * Get or create a Payload for an API request.
-   */
-  static get(attrs, createNew) {
+  function get(attrs, createNew) {
     let entity;
     let needsUpdate = false;
     if (!createNew) {
-      entity = this.cached(attrs);
+      entity = cached(attrs);
     }
     if (!entity) {
-      entity = this.create(attrs);
+      entity = create(attrs);
       needsUpdate = true;
     }
     return { entity, needsUpdate };
   }
-  /**
-   * Get cached Payload if available and not expired.
-   */
-  static cached(attrs) {
-    const meta = this.meta(attrs);
-    const cache = toCacheValue(attrs["cache"]) || meta.cache || 0;
+  function cached(attrs) {
+    const m = meta(attrs);
+    const cache = toCacheValue(attrs["cache"]) || m.cache || 0;
     let cacheKey = "";
     if (cache) {
-      cacheKey = defaultCacheKey(meta, attrs);
+      cacheKey = defaultCacheKey(m, attrs);
     }
     if (cacheKey) {
-      const info = this._pendingCacheKeys[cacheKey];
+      const info = pendingCacheKeys[cacheKey];
       if (info) {
         const entity = info.entity;
-        return entity instanceof Payload ? entity : void 0;
+        return isPayload(entity) ? entity : void 0;
       }
-      const cached = this._payloadCache.get(cacheKey);
-      if (cached && cached.cacheInfo) {
-        if (Date.now() - cached.cacheInfo.time > cache) {
-          this._payloadCache.del(cacheKey);
+      const cachedPayload = payloadCache.get(cacheKey);
+      if (cachedPayload && cachedPayload.cacheInfo) {
+        if (Date.now() - cachedPayload.cacheInfo.time > cache) {
+          payloadCache.del(cacheKey);
           return void 0;
         }
-        return cached;
+        return cachedPayload;
       }
     }
     return void 0;
   }
-  /**
-   * Clear cached payloads by endpoint name.
-   */
-  static clear(names) {
-    const nameSet = new Set(
-      (typeof names === "string" ? names : names.join(",")).split(",")
-    );
+  function clear(names) {
+    const nameSet = new Set((typeof names === "string" ? names : names.join(",")).split(","));
     const keysToDelete = [];
-    this._payloadCache.forEach((payload) => {
+    payloadCache.forEach((payload) => {
       const info = payload?.cacheInfo;
       if (info && info.key && nameSet.has(info.name)) {
         keysToDelete.push(info.key);
       }
     });
     for (const key of keysToDelete) {
-      this._payloadCache.del(key);
+      payloadCache.del(key);
     }
   }
-  // Static event methods (operate on per-type emitter)
-  static on(event, handler) {
-    this._staticEmitter.on(event, handler);
+  function on(event, handler) {
+    staticEmitter2.on(event, handler);
   }
-  static off(event, handler) {
-    this._staticEmitter.off(event, handler);
+  function off(event, handler) {
+    staticEmitter2.off(event, handler);
   }
-  static fire(event, data) {
-    this._staticEmitter.fire(event, data);
+  function fire(event, data) {
+    staticEmitter2.fire(event, data);
   }
-  /**
-   * Create a new Service subclass with a custom sync function.
-   *
-   * Each subclass gets its OWN copies of every per-type static field
-   * (`_metaList`, `_payloadCache`, `_pendingCacheKeys`, `_syncFn`,
-   * `_staticEmitter`, `_cacheMax`, `_cacheBuffer`) via `static override`.
-   * This is intentional: it ensures that endpoint metadata, cache state,
-   * in-flight dedup keys, and event subscribers are fully isolated between
-   * different Service types, even when one extends another.
-   *
-   * **Do not refactor these `static override` declarations away** — sharing
-   * them through prototype inheritance would let endpoints registered on one
-   * subclass leak into another, and the LFU cache evictions of one type
-   * would race with those of another.
-   */
-  static extend(newSyncFn, newCacheMax, newCacheBuffer) {
-    const ParentService = this;
-    class ChildService extends ParentService {
-      // Intentionally per-subclass — see Service.extend doc.
-      static _metaList = {};
-      static _payloadCache = new Cache({
-        maxSize: newCacheMax || ParentService._cacheMax,
-        bufferSize: newCacheBuffer || ParentService._cacheBuffer
-      });
-      static _pendingCacheKeys = {};
-      static _syncFn = newSyncFn;
-      static _staticEmitter = new EventEmitter();
-      static _cacheMax = newCacheMax || ParentService._cacheMax;
-      static _cacheBuffer = newCacheBuffer || ParentService._cacheBuffer;
+  function instance() {
+    const id = generateId("service");
+    const instEmitter = createEmitter();
+    const taskQueue = [];
+    let prevArgs = [];
+    function all(attrs, done) {
+      serviceSend(inst, attrs, done, FETCH_FLAGS_ALL, false, internals);
+      return inst;
+    }
+    function one(attrs, done) {
+      serviceSend(inst, attrs, done, FETCH_FLAGS_ONE, false, internals);
+      return inst;
+    }
+    function save(attrs, done) {
+      serviceSend(inst, attrs, done, FETCH_FLAGS_ALL, true, internals);
+      return inst;
+    }
+    function enqueue(callback) {
+      if (!inst.destroyed) {
+        taskQueue.push(callback);
+        dequeue(...prevArgs);
+      }
+      return inst;
+    }
+    function dequeue(...args) {
+      if (!inst.busy && !inst.destroyed) {
+        inst.busy = 1;
+        setTimeout(() => {
+          inst.busy = 0;
+          if (!inst.destroyed) {
+            const task2 = taskQueue.shift();
+            if (task2) {
+              prevArgs = args;
+              funcWithTry(task2, args, inst, noop);
+            }
+          }
+        }, 0);
+      }
     }
-    return ChildService;
+    function destroy() {
+      inst.destroyed = 1;
+      taskQueue.length = 0;
+    }
+    function onInst(event, handler) {
+      instEmitter.on(event, handler);
+      return inst;
+    }
+    function offInst(event, handler) {
+      instEmitter.off(event, handler);
+      return inst;
+    }
+    function fireInst(event, data) {
+      instEmitter.fire(event, data);
+      return inst;
+    }
+    const inst = {
+      id,
+      busy: 0,
+      destroyed: 0,
+      emitter: instEmitter,
+      all,
+      one,
+      save,
+      enqueue,
+      dequeue,
+      destroy,
+      on: onInst,
+      off: offInst,
+      fire: fireInst
+    };
+    return inst;
   }
-};
+  return { add, meta, create, get, cached, clear, on, off, fire, instance };
+}
 var metaJsonCache = /* @__PURE__ */ new WeakMap();
 function getMetaJson(meta) {
   let cached = metaJsonCache.get(meta);
@@ -4060,10 +3475,10 @@ function toCacheValue(v) {
   }
   return 0;
 }
-function serviceSend(service, attrs, done, flag, save) {
+function serviceSend(service, attrs, done, flag, save, internals) {
   if (service.destroyed) return;
   if (service.busy) {
-    const queued = () => serviceSend(service, attrs, done, flag, save);
+    const queued = () => serviceSend(service, attrs, done, flag, save, internals);
     service.enqueue(queued);
     return;
   }
@@ -4076,8 +3491,7 @@ function serviceSend(service, attrs, done, flag, save) {
   } else {
     attrList = [attrs];
   }
-  const internals = service.internals;
-  const { syncFn, pendingCacheKeys, staticEmitter: staticEmitter2 } = internals;
+  const { syncFn, pendingCacheKeys, staticEmitter: staticEmitter2, payloadCache } = internals;
   let requestCount = 0;
   const total = attrList.length;
   const doneArr = new Array(total + 1);
@@ -4102,7 +3516,7 @@ function serviceSend(service, attrs, done, flag, save) {
         }
       }
       if (flag === FETCH_FLAGS_ONE) {
-        funcWithTry(done, [error || null, payload, finish, idx], service, noop);
+        funcWithTry(done, [error ?? null, payload, finish, idx], service, noop);
       }
     }
     if (newPayload) {
@@ -4112,9 +3526,9 @@ function serviceSend(service, attrs, done, flag, save) {
   for (const attr of attrList) {
     if (!attr) continue;
     const attrObj = typeof attr === "string" ? { name: attr } : attr;
-    const payloadInfo = service.type.get(attrObj, save);
+    const payloadInfo = internals ? getPayload(internals, attrObj, save) : { entity: createPayload(), needsUpdate: true };
     const payloadEntity = payloadInfo.entity;
-    const cacheKey = payloadEntity.cacheInfo?.key || "";
+    const cacheKey = payloadEntity.cacheInfo?.key ?? "";
     doneArr[requestCount + 1] = payloadEntity;
     const complete = remoteComplete.bind(null, requestCount++);
     if (cacheKey && pendingCacheKeys[cacheKey]) {
@@ -4127,9 +3541,9 @@ function serviceSend(service, attrs, done, flag, save) {
         const cacheComplete = () => {
           const list = pendingCacheKeys[cacheKey];
           const entity = list.entity;
-          if (entity instanceof Payload && entity.cacheInfo) {
+          if (isPayload(entity) && entity.cacheInfo) {
             entity.cacheInfo.time = Date.now();
-            internals.payloadCache.set(cacheKey, entity);
+            payloadCache.set(cacheKey, entity);
           }
           Reflect.deleteProperty(pendingCacheKeys, cacheKey);
           for (const cb of list) {
@@ -4145,6 +3559,55 @@ function serviceSend(service, attrs, done, flag, save) {
     }
   }
 }
+function getPayload(internals, attrs, createNew) {
+  const metaList = internals.metaList;
+  const name = String(attrs["name"] ?? "");
+  const known = metaList[name];
+  const m = known ?? (isServiceMetaEntry(attrs) ? attrs : { name, url: "" });
+  const cache = toCacheValue(attrs["cache"]) || m.cache || 0;
+  let cacheKey = "";
+  if (cache) {
+    cacheKey = defaultCacheKey(m, attrs);
+  }
+  let entity;
+  let needsUpdate = false;
+  if (!createNew && cacheKey) {
+    const info = internals.pendingCacheKeys[cacheKey];
+    if (info) {
+      const e = info.entity;
+      if (isPayload(e)) entity = e;
+    }
+    if (!entity) {
+      const cachedPayload = internals.payloadCache.get(cacheKey);
+      if (cachedPayload && cachedPayload.cacheInfo) {
+        if (Date.now() - cachedPayload.cacheInfo.time > cache) {
+          internals.payloadCache.del(cacheKey);
+        } else {
+          entity = cachedPayload;
+        }
+      }
+    }
+  }
+  if (!entity) {
+    entity = createPayload();
+    entity.set(m);
+    entity.cacheInfo = {
+      name: m.name,
+      after: typeof m.after === "function" ? m.after : void 0,
+      cleans: typeof m.cleanKeys === "string" ? m.cleanKeys : void 0,
+      key: cacheKey,
+      time: 0
+    };
+    if (attrs) entity.set(attrs);
+    const before = m.before;
+    if (typeof before === "function") {
+      funcWithTry(before, [entity], entity, noop);
+    }
+    internals.staticEmitter.fire("begin", { payload: entity });
+    needsUpdate = true;
+  }
+  return { entity, needsUpdate };
+}
 
 // src/devtool.ts
 var FrameDevtoolBridge = {
@@ -4155,10 +3618,10 @@ var FrameDevtoolBridge = {
   MSG_TREE_DELTA: "LARK_DEVTOOL_TREE_DELTA"
 };
 function serializeView(view) {
-  const evtMap = view.eventObjectMap;
+  const evtMap = {};
   const eventMethodKeys = evtMap ? Object.keys(evtMap) : [];
   const resourceKeys = view.resources ? Object.keys(view.resources) : [];
-  const hasAssign = typeof view["assign"] === "function";
+  const hasAssign = typeof view.getAssign() === "function";
   let updaterData = null;
   try {
     const ref = view.updater?.refData;
@@ -4174,14 +3637,14 @@ function serializeView(view) {
   return {
     id: view.id,
     rendered: !!view.rendered,
-    signature: view.signature,
-    observedStateKeys: view.observedStateKeys ?? null,
+    signature: view.signature.value,
+    observedStateKeys: view.getObservedStateKeys() ?? null,
     locationObserved: {
       flag: view.locationObserved.flag,
       keys: view.locationObserved.keys,
       observePath: view.locationObserved.observePath
     },
-    hasTemplate: !!view.template,
+    hasTemplate: !!view.getTemplate(),
     eventMethodKeys,
     resourceKeys,
     hasAssign,
@@ -4202,7 +3665,7 @@ function serializeFrame(frameId) {
   return {
     id: frame.id,
     parentId: frame.parentId ?? null,
-    viewPath: frame.viewPath ?? null,
+    viewPath: frame.getViewPath() ?? null,
     childrenCount: frame.childrenCount,
     readyCount: frame.readyCount,
     childrenCreated: frame.childrenCreated,
@@ -4247,10 +3710,7 @@ function installFrameDevtoolBridge() {
     if (type === FrameDevtoolBridge.MSG_PING) {
       const source = event.source;
       if (source) {
-        source.postMessage(
-          { type: FrameDevtoolBridge.MSG_PONG },
-          { targetOrigin: "*" }
-        );
+        source.postMessage({ type: FrameDevtoolBridge.MSG_PONG }, { targetOrigin: "*" });
       }
       return;
     }
@@ -4278,15 +3738,15 @@ function pushTreeUpdate() {
   const treeJson = JSON.stringify(tree);
   if (treeJson !== lastTreeJson) {
     lastTreeJson = treeJson;
-    window.parent.postMessage(
-      { type: FrameDevtoolBridge.MSG_TREE_DELTA, data: tree },
-      "*"
-    );
+    window.parent.postMessage({ type: FrameDevtoolBridge.MSG_TREE_DELTA, data: tree }, "*");
   }
 }
 
 // src/framework.ts
 var booted3 = false;
+function isAnyFunc(v) {
+  return typeof v === "function";
+}
 var taskList = [];
 var taskIndex = 0;
 var taskScheduled = false;
@@ -4295,7 +3755,7 @@ function executeTaskChunk(deadline) {
   const startTime = Date.now();
   while (true) {
     const fn = taskList[taskIndex];
-    if (!fn) {
+    if (!isAnyFunc(fn)) {
       taskList.length = 0;
       taskIndex = 0;
       taskScheduled = false;
@@ -4311,7 +3771,8 @@ function executeTaskChunk(deadline) {
       return;
     }
     const context = taskList[taskIndex + 1];
-    const args = taskList[taskIndex + 2];
+    const rawArgs = taskList[taskIndex + 2];
+    const args = Array.isArray(rawArgs) ? rawArgs : [];
     funcWithTry(fn, args, context, noop);
     taskIndex += 3;
   }
@@ -4335,7 +3796,7 @@ function task(fn, args, context) {
 }
 var dispatcherUpdateTag = 0;
 function isThenable(value) {
-  return !!value && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
+  return !!value && (typeof value === "object" || typeof value === "function") && "then" in value && typeof Reflect.get(value, "then") === "function";
 }
 function viewIsObserveChanged(view) {
   const loc = view.locationObserved;
@@ -4359,7 +3820,7 @@ function viewIsObserveChanged(view) {
   return result;
 }
 function stateIsObserveChanged(view, stateKeys) {
-  const observedKeys = view.observedStateKeys;
+  const observedKeys = view.getObservedStateKeys();
   if (!observedKeys) return false;
   for (const key of observedKeys) {
     if (stateKeys.has(key)) return true;
@@ -4371,21 +3832,16 @@ function dispatcherUpdate(frame, stateKeys) {
   const drain = (s) => {
     while (s.length > 0) {
       const current = s.pop();
-      const tagged = current;
+      if (!current) continue;
       const view = current.view;
-      if (!view || tagged.dispatcherUpdateTag === dispatcherUpdateTag || view.signature <= 1) {
+      if (!view || current.dispatcherUpdateTag === dispatcherUpdateTag || view.signature.value <= 1) {
         continue;
       }
-      tagged.dispatcherUpdateTag = dispatcherUpdateTag;
+      current.dispatcherUpdateTag = dispatcherUpdateTag;
       const isChanged = stateKeys ? stateIsObserveChanged(view, stateKeys) : viewIsObserveChanged(view);
       let renderPromise;
       if (isChanged) {
-        const renderResult = funcWithTry(
-          view.renderMethod ?? view.render,
-          [],
-          view,
-          noop
-        );
+        const renderResult = funcWithTry(view.renderMethod ?? view.render, [], view, noop);
         if (isThenable(renderResult)) {
           renderPromise = renderResult;
         }
@@ -4413,10 +3869,9 @@ function dispatcherUpdate(frame, stateKeys) {
 function dispatcherNotifyChange(e) {
   const rootFrame2 = Frame.getRoot();
   if (!rootFrame2) return;
-  const routeEvent = e;
-  const view = routeEvent.view;
-  if (view) {
-    const viewPath = typeof view === "object" && view !== null ? String(view.to || "") : String(view);
+  if ("view" in e && e.view !== void 0) {
+    const view = e.view;
+    const viewPath = typeof view === "object" && view !== null ? String(Reflect.get(view, "to") || "") : String(view);
     rootFrame2.mountView(viewPath);
   } else {
     dispatcherUpdateTag++;
@@ -4455,16 +3910,16 @@ function waitZoneViewsRendered(viewId, timeout) {
 }
 function getConfigImpl(key) {
   if (key === void 0) return config;
-  return config[key];
+  return Reflect.get(config, key);
 }
 var Framework = {
   // ============================================================
   // Lifecycle
   // ============================================================
-  /** Read framework configuration. See `FrameworkInterface.getConfig`. */
+  /** Read framework configuration. See `FrameworkApi.getConfig`. */
   getConfig: getConfigImpl,
   /**
-   * Merge a patch into framework configuration. See `FrameworkInterface.setConfig`.
+   * Merge a patch into framework configuration. See `FrameworkApi.setConfig`.
    */
   setConfig(patch) {
     if (patch && typeof patch === "object") {
@@ -4490,11 +3945,13 @@ var Framework = {
     booted3 = true;
     markBooted();
     markRouterBooted();
-    installFrameDevtoolBridge();
+    if (config.devtool) {
+      installFrameDevtoolBridge();
+    }
     const rootFrame2 = Frame.createRoot(config.rootId);
     Router._bind();
     const defaultView = config.defaultView || "";
-    if (defaultView && !rootFrame2.view) {
+    if (defaultView && !rootFrame2.getViewPath()) {
       rootFrame2.mountView(defaultView);
     }
   },
@@ -4510,7 +3967,7 @@ var Framework = {
   /** Unmark (invalidate) async callbacks */
   unmark,
   /** Fire a custom DOM event on a target */
-  dispatch: dispatchEvent,
+  dispatchEvent,
   /** Execute function in try-catch, ignoring errors */
   task,
   /** Promise-based setTimeout */
@@ -4521,32 +3978,20 @@ var Framework = {
   use,
   /** Wait for zone views to be rendered */
   waitZoneViewsRendered,
-  WAIT_OK,
-  WAIT_TIMEOUT_OR_NOT_FOUND,
-  /**
-   * Convert array to hash map.
-   */
-  toMap,
-  /**
-   * Execute function in try-catch.
-   */
-  toTry: funcWithTry,
   /**
    * Convert path + params to URL string.
    */
-  toUrl: toUri,
+  toUri,
   /**
    * Parse URI string into path and params.
    */
-  parseUrl: parseUri,
+  parseUri,
+  WAIT_OK,
+  WAIT_TIMEOUT_OR_NOT_FOUND,
   /**
    * Mix properties from source to target.
    */
-  mix: assign,
-  /**
-   * Check if object has own property.
-   */
-  has: hasOwnProperty,
+  assign,
   /**
    * Get object keys.
    */
@@ -4554,27 +3999,19 @@ var Framework = {
   /**
    * Check if node A is inside node B.
    */
-  inside: nodeInside,
-  /**
-   * Get element by ID (shorthand for document.getElementById).
-   */
-  node: getById,
-  /**
-   * Apply CSS style.
-   */
-  applyStyle,
+  nodeInside,
   /**
    * Generate globally unique ID.
    */
-  guid: generateId,
+  generateId,
   /**
-   * Cache class.
+   * Cache factory (functional).
    */
-  Cache,
+  createCache,
   /**
    * Ensure element has an ID.
    */
-  nodeId(element) {
+  ensureNodeId(element) {
     if (!element.id) {
       element.id = generateId("l_");
     }
@@ -4583,7 +4020,7 @@ var Framework = {
   /**
    * Base class with EventEmitter.
    */
-  Base: EventEmitter,
+  createEmitter,
   // ============================================================
   // Module access
   // ============================================================
@@ -4591,21 +4028,11 @@ var Framework = {
   Router,
   /** State module */
   State,
-  /** View class */
-  View,
+  /** View factory (functional) */
+  defineView,
   /** Frame class */
   Frame
 };
-if (typeof window !== "undefined") {
-  window.__lark_Framework = Framework;
-  window.__lark_State = State;
-  window.__lark_Router = Router;
-  window.__lark_Frame = Frame;
-  window.__lark_View = View;
-  window.__lark_invalidateViewClass = invalidateViewClass;
-  window.__lark_getViewClassRegistry = getViewClassRegistry;
-  window.__lark_registerViewClass = registerViewClass;
-}
 
 // src/url-state.ts
 function useUrlState(view, initialState) {
@@ -4630,157 +4057,313 @@ function useUrlState(view, initialState) {
   return [getState(), setState];
 }
 
-// src/store.ts
-var COMPUTED_BRAND = /* @__PURE__ */ Symbol("lark-store-computed");
-function isComputedMarker(val) {
-  return val !== null && typeof val === "object" && val[COMPUTED_BRAND] === true;
+// src/hmr.ts
+function reloadViews(viewPath) {
+  const allFrames = Frame.getAll();
+  const toReload = [];
+  for (const [, frame] of allFrames) {
+    const vp = frame.getViewPath();
+    if (vp) {
+      const parsed = parseUri(vp);
+      if (parsed.path === viewPath) {
+        toReload.push({ frame, fullPath: vp });
+      }
+    }
+  }
+  for (const { frame, fullPath } of toReload) {
+    frame.mountView(fullPath);
+  }
 }
-function computed(deps, fn) {
-  return { [COMPUTED_BRAND]: true, deps, fn };
+function hotSwapView(frame, newSetup) {
+  const oldView = frame.view;
+  if (!oldView) {
+    const vp = frame.getViewPath();
+    if (vp) frame.mountView(vp);
+    return;
+  }
+  for (let i = oldView.cleanups.length - 1; i >= 0; i--) {
+    oldView.cleanups[i]();
+  }
+  oldView.cleanups.length = 0;
+  unregisterEvents(oldView);
+  destroyAllResources(oldView, false);
+  setCurrentCtx(oldView);
+  let descriptor;
+  try {
+    descriptor = newSetup(oldView, void 0);
+  } finally {
+    setCurrentCtx(null);
+  }
+  oldView.setTemplate(descriptor.template);
+  oldView.setEvents(descriptor.events);
+  if (descriptor.assign) oldView.setAssign(descriptor.assign);
+  registerEvents(oldView);
+  if (oldView.signature.value > 0) {
+    oldView.signature.value++;
+    oldView.fire("render");
+    destroyAllResources(oldView, false);
+    oldView.updater.forceDigest();
+  }
 }
-var storeRegistry = /* @__PURE__ */ new Map();
-function create(name, creator) {
-  const listeners = /* @__PURE__ */ new Set();
-  const computedDefs = /* @__PURE__ */ new Map();
-  const computedKeys = /* @__PURE__ */ new Set();
-  const actionKeys = /* @__PURE__ */ new Set();
-  let state;
-  let destroyed = false;
-  const getState = () => state;
-  const setState = (partial) => {
-    if (destroyed) return;
-    const prevState = state;
-    const resolved = typeof partial === "function" ? partial(prevState) : partial;
-    const nextState = { ...prevState };
-    let changed = false;
-    for (const key in resolved) {
-      if (Object.prototype.hasOwnProperty.call(resolved, key) && !computedKeys.has(key) && !actionKeys.has(key)) {
-        const newVal = resolved[key];
-        if (!Object.is(prevState[key], newVal)) {
-          nextState[key] = newVal;
-          changed = true;
-        }
+function findFramesByViewPath(viewPath) {
+  const result = [];
+  for (const [, frame] of Frame.getAll()) {
+    const vp = frame.getViewPath();
+    if (vp) {
+      const parsed = parseUri(vp);
+      if (parsed.path === viewPath) {
+        result.push({ frame, fullPath: vp });
       }
     }
-    if (!changed) return;
-    state = nextState;
-    recomputeIfNeeded(prevState);
-    for (const listener of listeners) {
-      listener(state, prevState);
-    }
-  };
-  const recomputeIfNeeded = (prevState) => {
-    if (computedDefs.size === 0) return;
-    const changedKeys2 = /* @__PURE__ */ new Set();
-    for (const key of Object.keys(state)) {
-      if (!Object.is(
-        state[key],
-        prevState[key]
-      )) {
-        changedKeys2.add(key);
-      }
+  }
+  return result;
+}
+function hotSwapFrames(viewPath, newSetup) {
+  const targets = findFramesByViewPath(viewPath);
+  for (const { frame } of targets) {
+    hotSwapView(frame, newSetup);
+  }
+}
+function hotSwapByTemplate(oldTemplate, newTemplate) {
+  if (!oldTemplate || !newTemplate || oldTemplate === newTemplate) return;
+  for (const [, frame] of Frame.getAll()) {
+    const view = frame.view;
+    if (!view || view.getTemplate() !== oldTemplate) continue;
+    view.setTemplate(newTemplate);
+    if (view.signature.value > 0) {
+      view.signature.value++;
+      view.fire("render");
+      destroyAllResources(view, false);
+      view.updater.forceDigest();
     }
-    for (const [key, def] of computedDefs) {
-      if (def.deps.some((dep) => changedKeys2.has(dep))) {
-        const newVal = def.fn();
-        if (!Object.is(state[key], newVal)) {
-          state[key] = newVal;
-        }
+  }
+}
+function hotSwapByView(oldSetup, newSetup) {
+  if (!oldSetup || !newSetup || oldSetup === newSetup) return;
+  const reg = getViewClassRegistry();
+  for (const path in reg) {
+    if (reg[path] === oldSetup) reg[path] = newSetup;
+  }
+  for (const [, frame] of Frame.getAll()) {
+    const view = frame.view;
+    const vp = frame.getViewPath();
+    if (view && vp) {
+      const parsed = parseUri(vp);
+      if (reg[parsed.path] === newSetup) {
+        hotSwapView(frame, newSetup);
       }
     }
-  };
-  const subscribe = (listener) => {
-    listeners.add(listener);
-    return () => {
-      listeners.delete(listener);
-    };
-  };
-  const destroy = () => {
-    destroyed = true;
-    listeners.clear();
-    storeRegistry.delete(name);
-  };
-  const api = { getState, setState, subscribe, destroy };
-  const body = creator(setState, getState);
-  const initialState = {};
-  const actions = {};
-  for (const key of Object.keys(body)) {
-    const val = body[key];
-    if (isComputedMarker(val)) {
-      computedDefs.set(key, val);
-      computedKeys.add(key);
-      initialState[key] = void 0;
-    } else if (typeof val === "function") {
-      actions[key] = val;
-      actionKeys.add(key);
-    } else {
-      initialState[key] = val;
+  }
+}
+
+// src/hmr-inject.ts
+var TEMPLATE_VAR = "__larkTemplate";
+function getTemplateHmrSnippet(bundler) {
+  if (bundler === "vite") {
+    return `
+// \u2500\u2500 Lark template HMR (auto-injected by larkMvcPlugin \u2014 Vite) \u2500\u2500
+if (import.meta.hot) {
+  import.meta.hot.dispose(function(__larkData) {
+    __larkData.oldTemplate = ${TEMPLATE_VAR};
+  });
+  import.meta.hot.accept(function(__larkNewModule) {
+    var __larkNew = __larkNewModule && __larkNewModule.default;
+    var __larkOld = import.meta.hot.data && import.meta.hot.data.oldTemplate;
+    if (__larkOld && __larkNew && __larkOld !== __larkNew) {
+      import("@lark.js/mvc").then(function(m) {
+        if (m && m.hotSwapByTemplate) m.hotSwapByTemplate(__larkOld, __larkNew);
+      });
     }
+  });
+}
+`;
   }
-  state = { ...initialState, ...actions };
-  for (const [key, def] of computedDefs) {
-    state[key] = def.fn();
+  return `
+// \u2500\u2500 Lark template HMR (auto-injected by larkMvcPlugin \u2014 ${bundler}) \u2500\u2500
+if (typeof module !== "undefined" && module.hot) {
+  module.hot.dispose(function(__larkData) {
+    __larkData.oldTemplate = ${TEMPLATE_VAR};
+  });
+  module.hot.accept(function() {
+    var __larkNew = ${TEMPLATE_VAR};
+    var __larkOld = module.hot && module.hot.data && module.hot.data.oldTemplate;
+    if (__larkOld && __larkNew && __larkOld !== __larkNew) {
+      import("@lark.js/mvc").then(function(m) {
+        if (m && m.hotSwapByTemplate) m.hotSwapByTemplate(__larkOld, __larkNew);
+      });
+    }
+  });
+}
+`;
+}
+function injectTemplateHmrSnippet(source, bundler) {
+  return source + "\n" + getTemplateHmrSnippet(bundler);
+}
+function getViewHmrSnippet(bundler) {
+  const VIEW_VAR = "__larkViewDefault";
+  if (bundler === "vite") {
+    return `
+// \u2500\u2500 Lark view class HMR (auto-injected by larkMvcPlugin \u2014 Vite) \u2500\u2500
+if (import.meta.hot) {
+  import.meta.hot.dispose(function(__larkData) {
+    __larkData.oldClass = ${VIEW_VAR};
+  });
+  import.meta.hot.accept(function(__larkNewModule) {
+    var __larkNew = __larkNewModule && __larkNewModule.default;
+    var __larkOld = import.meta.hot.data && import.meta.hot.data.oldClass;
+    if (__larkOld && __larkNew && __larkOld !== __larkNew) {
+      import("@lark.js/mvc").then(function(m) {
+        if (m && m.hotSwapByView) m.hotSwapByView(__larkOld, __larkNew);
+      });
+    }
+  });
+}
+`;
   }
-  storeRegistry.set(name, api);
-  return api;
+  return `
+// \u2500\u2500 Lark view class HMR (auto-injected by larkMvcPlugin \u2014 ${bundler}) \u2500\u2500
+if (typeof module !== "undefined" && module.hot) {
+  module.hot.dispose(function(__larkData) {
+    __larkData.oldClass = ${VIEW_VAR};
+  });
+  module.hot.accept(function() {
+    var __larkNew = ${VIEW_VAR};
+    var __larkOld = module.hot && module.hot.data && module.hot.data.oldClass;
+    if (__larkOld && __larkNew && __larkOld !== __larkNew) {
+      import("@lark.js/mvc").then(function(m) {
+        if (m && m.hotSwapByView) m.hotSwapByView(__larkOld, __larkNew);
+      });
+    }
+  });
 }
-function isLarkView(instance) {
-  if (!instance || typeof instance !== "object") return false;
-  const obj = instance;
-  const updater = obj["updater"];
-  return updater !== null && typeof updater === "object" && typeof updater["set"] === "function" && typeof updater["digest"] === "function";
+`;
 }
-function bindStore(view, store, selector) {
-  if (!isLarkView(view)) return () => {
-  };
-  const extract = (s) => {
-    if (selector) return selector(s);
-    const result = {};
-    for (const key in s) {
-      if (Object.prototype.hasOwnProperty.call(s, key) && typeof s[key] !== "function") {
-        result[key] = s[key];
+var HTML_IMPORT_RE = /import\s+(?:template\s+from\s+|.*from\s+)?["'][^"']+\.html["']/;
+function importsHtmlTemplate(source) {
+  return HTML_IMPORT_RE.test(source);
+}
+function injectViewHmr(source, bundler) {
+  if (!importsHtmlTemplate(source)) return source;
+  const exportDefaultRe = /export\s+default\s+/;
+  const match = exportDefaultRe.exec(source);
+  if (!match) return source;
+  const startIdx = match.index + match[0].length;
+  const endIdx = findExpressionEnd(source, startIdx);
+  if (endIdx === -1) return source;
+  const expression = source.substring(startIdx, endIdx);
+  const before = source.substring(0, match.index);
+  const after = source.substring(endIdx);
+  const VIEW_VAR = "__larkViewDefault";
+  const transformed = before + `const ${VIEW_VAR} = ${expression};
+export default ${VIEW_VAR};` + after + "\n" + getViewHmrSnippet(bundler);
+  return transformed;
+}
+function findExpressionEnd(source, startIdx) {
+  let depth = 0;
+  let inString = null;
+  let inTemplate = false;
+  let inLineComment = false;
+  let inBlockComment = false;
+  for (let i = startIdx; i < source.length; i++) {
+    const ch = source[i];
+    const next = source[i + 1];
+    if (inLineComment) {
+      if (ch === "\n") inLineComment = false;
+      continue;
+    }
+    if (inBlockComment) {
+      if (ch === "*" && next === "/") {
+        inBlockComment = false;
+        i++;
       }
+      continue;
     }
-    return result;
-  };
-  view.updater.set(extract(store.getState()));
-  view.updater.digest();
-  const off = store.subscribe((state) => {
-    view.updater.set(extract(state));
-    view.updater.digest();
-  });
-  view.on("destroy", off);
-  return off;
+    if (inString) {
+      if (ch === "\\") {
+        i++;
+        continue;
+      }
+      if (ch === inString) inString = null;
+      continue;
+    }
+    if (inTemplate) {
+      if (ch === "\\") {
+        i++;
+        continue;
+      }
+      if (ch === "`") inTemplate = false;
+      continue;
+    }
+    if (ch === "/" && next === "/") {
+      inLineComment = true;
+      i++;
+      continue;
+    }
+    if (ch === "/" && next === "*") {
+      inBlockComment = true;
+      i++;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      inString = ch;
+      continue;
+    }
+    if (ch === "`") {
+      inTemplate = true;
+      continue;
+    }
+    if (ch === "(" || ch === "{" || ch === "[") {
+      depth++;
+      continue;
+    }
+    if (ch === ")" || ch === "}" || ch === "]") {
+      depth--;
+      if (depth === 0) {
+        return i + 1;
+      }
+      continue;
+    }
+    if (depth === 0 && ch === ";") {
+      return i;
+    }
+  }
+  return -1;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CALL_BREAK_TIME,
-  Cache,
   CrossSite,
   EVENT_METHOD_REGEXP,
   EventDelegator,
-  EventEmitter,
   Frame,
   Framework,
   LARK_VIEW,
-  Payload,
   ROUTER_EVENTS,
   Router,
   SPLITTER,
-  Service,
   State,
   TAG_NAME_REGEXP,
-  Updater,
   VIEW_EVENT_METHOD_REGEXP,
-  View,
-  applyStyle,
   bindStore,
   computed,
-  create,
+  createCache,
+  createEmitter,
+  createFrame,
+  createPayload,
+  createService,
+  createStore,
+  createUpdater,
   createVDomRef,
   defineView,
   frameworkConfig,
   getRouteMode,
+  hotSwapByTemplate,
+  hotSwapByView,
+  hotSwapFrames,
+  hotSwapView,
+  importsHtmlTemplate,
+  injectTemplateHmrSnippet,
+  injectViewHmr,
   invalidateViewClass,
   mark,
   markBooted,
@@ -4791,6 +4374,13 @@ function bindStore(view, store, selector) {
   resetProjectsMap,
   unmark,
   use,
+  useEffect,
+  useEvent,
+  useInterval,
+  useResource,
+  useState,
+  useStore,
+  useTimeout,
   useUrlState,
   vdomCreate
 });