@lark.js/mvc 0.0.4 → 0.0.5

package/dist/index.js

@@ -1,12 +1,12 @@
 // src/constants.ts
 var globalCounter = 0;
 var SPLITTER = "";
-var ROUTER_EVENTS = {
+var RouterEvents = {
   CHANGE: "change",
   CHANGED: "changed",
   PAGE_UNLOAD: "page_unload"
 };
-var LARK_KEYS = {
+var LarkInnerKeys = {
   /** Attribute name: ldk (static key for skipping VDOM diff) */
   DIFF_KEY: "ldk",
   /** Attribute name: lak (static attribute key) */
@@ -53,13 +53,13 @@ function syncCounter(val) {
 }
 function noop() {
 }
-function has(owner, prop) {
+function hasOwnProperty(owner, prop) {
   return owner != null && Object.prototype.hasOwnProperty.call(owner, prop);
 }
 function keys(obj) {
   const result = [];
   for (const p in obj) {
-    if (has(obj, p)) {
+    if (hasOwnProperty(obj, p)) {
       result.push(p);
     }
   }
@@ -69,7 +69,7 @@ function assign(target, ...sources) {
   for (const source of sources) {
     if (source) {
       for (const p in source) {
-        if (has(source, p)) {
+        if (hasOwnProperty(source, p)) {
           target[p] = source[p];
         }
       }
@@ -82,21 +82,22 @@ function funcWithTry(fns, args, context, configError) {
   let ret;
   for (const fn of fnArray) {
     try {
-      ret = Function.prototype.apply.call(fn, context, args);
+      ret = fn.apply(context, args);
     } catch (e) {
       configError?.(e);
     }
   }
   return ret;
 }
+var EMPTY_STRING_SET = /* @__PURE__ */ new Set();
 function setData(newData, oldData, changedKeys2, excludes) {
   let changed = false;
   for (const p in newData) {
-    if (has(newData, p)) {
+    if (hasOwnProperty(newData, p)) {
       const now2 = newData[p];
       const old = oldData[p];
       if ((!isPrimitiveOrFunc(now2) || old !== now2) && !excludes.has(p)) {
-        changedKeys2[p] = 1;
+        changedKeys2.add(p);
         changed = true;
       }
       oldData[p] = now2;
@@ -104,17 +105,25 @@ function setData(newData, oldData, changedKeys2, excludes) {
   }
   return changed;
 }
+function isRefToken(s) {
+  if (s.length < 2 || s[0] !== SPLITTER) return false;
+  for (let i = 1; i < s.length; i++) {
+    const c = s.charCodeAt(i);
+    if (c < 48 || c > 57) return false;
+  }
+  return true;
+}
 function translateData(data, value) {
   if (isPrimitive(value)) {
     const prop = String(value);
-    if (prop[0] === SPLITTER && has(data, prop)) {
+    if (isRefToken(prop) && hasOwnProperty(data, prop)) {
       return data[prop];
     }
     return value;
   }
   if (isPlainObject(value) || Array.isArray(value)) {
     for (const p in value) {
-      if (has(value, p)) {
+      if (hasOwnProperty(value, p)) {
         const val = value[p];
         const newVal = translateData(data, val);
         value[p] = newVal;
@@ -151,38 +160,33 @@ function nodeInside(a, b) {
     return false;
   }
 }
-var paramsTemp = {};
-function paramsReplacer(_match, name, value) {
-  try {
-    paramsTemp[name] = decodeURIComponent(value || "");
-  } catch {
-    paramsTemp[name] = value || "";
-  }
-  return "";
-}
 function parseUri(uri) {
-  paramsTemp = {};
+  const params = {};
   const path = uri.replace(URL_QUERY_HASH_REGEXP, "");
   const pathname = path;
   const actualPath = uri === pathname && IS_URL_PARAMS.test(pathname) ? "" : pathname;
-  uri.replace(actualPath, "").replace(URL_PARAM_REGEXP, paramsReplacer);
-  return {
-    path: actualPath,
-    params: { ...paramsTemp }
-  };
+  uri.replace(actualPath, "").replace(URL_PARAM_REGEXP, (_match, name, value) => {
+    try {
+      params[name] = decodeURIComponent(value || "");
+    } catch {
+      params[name] = value || "";
+    }
+    return "";
+  });
+  return { path: actualPath, params };
 }
 var IS_URL_PARAMS = {
   test(s) {
     return /(?!^)=|&/.test(s);
   }
 };
-function toUri(path, params, keepEmptyObject) {
+function toUri(path, params, keepEmpty) {
   const pairs = [];
   let hasParams = false;
   for (const p in params) {
-    if (has(params, p)) {
+    if (hasOwnProperty(params, p)) {
       const v = String(params[p] ?? "");
-      if (!keepEmptyObject || v || has(keepEmptyObject, p)) {
+      if (!keepEmpty || v || keepEmpty.has(p)) {
         pairs.push(`${p}=${encodeURIComponent(v)}`);
         hasParams = true;
       }
@@ -205,14 +209,6 @@ function toMap(list, key) {
 function now() {
   return Date.now ? Date.now() : (/* @__PURE__ */ new Date()).getTime();
 }
-function classExtend(make, base, props, statics) {
-  const baseProto = base["prototype"] ?? {};
-  const classProto = Object.create(baseProto);
-  assign(classProto, props);
-  Object.assign(make, statics);
-  classProto.constructor = make;
-  make["prototype"] = classProto;
-}
 
 // src/apply-style.ts
 var injectedStyleIds = /* @__PURE__ */ new Set();
@@ -252,27 +248,35 @@ function applyStyle(styleIdOrPairs, css) {
 }
 
 // src/mark.ts
-var DELETED_KEY = SPLITTER + "$delFlag";
-var MARK_OBJECT_KEY = SPLITTER + "$markKey";
+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) {
-  let sign = 0;
-  const hostRecord = host;
-  if (!hostRecord[DELETED_KEY]) {
-    const markHost = hostRecord[MARK_OBJECT_KEY] || (hostRecord[MARK_OBJECT_KEY] = {});
-    if (!Object.prototype.hasOwnProperty.call(markHost, key)) {
-      markHost[key] = 0;
-    }
-    sign = ++markHost[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 temp = hostRecord[MARK_OBJECT_KEY];
-    return !!(temp && sign === temp[key]);
+    const current = hostStore.get(host);
+    return !!current && !current.deleted && current.signs.get(key) === sign;
   };
 }
 function unmark(host) {
-  const hostRecord = host;
-  hostRecord[MARK_OBJECT_KEY] = 0;
-  hostRecord[DELETED_KEY] = 1;
+  const record = hostStore.get(host);
+  if (record) {
+    record.deleted = true;
+    record.signs.clear();
+  } else {
+    hostStore.set(host, { signs: /* @__PURE__ */ new Map(), deleted: true });
+  }
 }
 
 // src/safeguard.ts
@@ -318,7 +322,7 @@ function safeguard(data, getter, setter, isRoot) {
         if (!prefix && getter) {
           getter(property);
         }
-        if (!isRoot && has(target, property) && (Array.isArray(out) || isPlainObject(out))) {
+        if (!isRoot && hasOwnProperty(target, property) && (Array.isArray(out) || isPlainObject(out))) {
           return build(prefix + property + ".", out);
         }
         return out;
@@ -407,15 +411,17 @@ var Cache = class {
     this.lookup.set(prefixedKey, entry);
   }
   /**
-   * Delete a cached entry.
+   * Delete a cached entry. Removes it immediately from both the lookup map
+   * and the entries array so the GC can reclaim the value without waiting
+   * for the next eviction sweep.
    */
   del(key) {
     const prefixedKey = this.prefixKey(key);
     const entry = this.lookup.get(prefixedKey);
     if (!entry) return;
-    entry.frequency = -1;
-    entry.value = void 0;
     this.lookup.delete(prefixedKey);
+    const idx = this.entries.indexOf(entry);
+    if (idx !== -1) this.entries.splice(idx, 1);
     if (this.onRemove) {
       this.onRemove(key);
     }
@@ -440,20 +446,46 @@ var Cache = class {
     this.entries = [];
     this.lookup.clear();
   }
-  /** Evict least-used entries from cache */
+  /**
+   * Evict the `bufferSize` worst entries from the cache.
+   *
+   * Uses single-pass partial selection (O(n·k)) instead of sorting the entire
+   * `entries` array (O(n log n)). For the typical `bufferSize = 5` this is
+   * effectively a linear scan with at most 5 in-bucket comparisons per
+   * iteration — and it avoids mutating the rest of `entries`.
+   */
   evictEntries() {
-    this.entries.sort(this.comparator);
-    let count = this.bufferSize;
-    while (count-- > 0 && this.entries.length > 0) {
-      const entry = this.entries.pop();
-      if (entry && entry.frequency > 0) {
-        this.lookup.delete(this.prefixKey(entry.originalKey));
-        if (this.onRemove) {
-          this.onRemove(entry.originalKey);
-        }
+    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 = this.entries.filter((e) => e.frequency !== -1);
+    this.entries = entries.filter((e) => !evictSet.has(e));
   }
 };
 
@@ -461,6 +493,10 @@ var Cache = class {
 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.
    */
@@ -483,13 +519,23 @@ var EventEmitter = class {
     const key = SPLITTER + event;
     if (handler) {
       const list = this.listeners.get(key);
-      if (list) {
+      if (!list) return this;
+      if (this.firingDepth > 0) {
         for (const listener of list) {
           if (listener.handler === handler) {
             listener.handler = noop;
+            (this.pendingCompaction ??= /* @__PURE__ */ new Set()).add(key);
+            break;
+          }
+        }
+      } else {
+        for (let i = 0; i < list.length; i++) {
+          if (list[i].handler === handler) {
+            list.splice(i, 1);
             break;
           }
         }
+        if (list.length === 0) this.listeners.delete(key);
       }
     } else {
       this.listeners.delete(key);
@@ -501,9 +547,9 @@ var EventEmitter = class {
     return this;
   }
   /**
-   * Fire event, execute all bound handlers.
-   * Supports executing state management: handlers removed during
-   * execution are safely handled.
+   * 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)
@@ -517,38 +563,41 @@ var EventEmitter = class {
       data = {};
     }
     data["type"] = event;
-    if (list) {
-      let end = list.length;
-      const len = end - 1;
-      while (end--) {
-        const idx = lastToFirst ? end : len - end;
-        const listener = list[idx];
-        if (listener.handler !== noop) {
+    this.firingDepth++;
+    try {
+      if (list) {
+        const len = list.length;
+        for (let i = 0; i < len; i++) {
+          const idx = lastToFirst ? len - 1 - i : i;
+          const listener = list[idx];
+          if (!listener) continue;
+          if (listener.handler === noop) continue;
           listener.executing = 1;
-          funcWithTry(
-            [listener.handler],
-            [data],
-            this,
-            noop
-          );
+          funcWithTry([listener.handler], [data], this, noop);
           listener.executing = "";
-        } else if (!listener.executing) {
-          list.splice(idx, 1);
         }
       }
-    }
-    const onMethodName = `on${event[0].toUpperCase() + event.slice(1)}`;
-    const onMethod = this[onMethodName];
-    if (typeof onMethod === "function") {
-      funcWithTry(
-        [onMethod],
-        [data],
-        this,
-        noop
-      );
-    }
-    if (remove) {
-      this.off(event);
+      const onMethodName = `on${event[0].toUpperCase() + event.slice(1)}`;
+      const onMethod = this[onMethodName];
+      if (typeof onMethod === "function") {
+        funcWithTry([onMethod], [data], this, noop);
+      }
+      if (remove) {
+        this.off(event);
+      }
+    } finally {
+      this.firingDepth--;
+      if (this.firingDepth === 0 && this.pendingCompaction) {
+        for (const k of this.pendingCompaction) {
+          const l = this.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);
+        }
+        this.pendingCompaction = void 0;
+      }
     }
     return this;
   }
@@ -557,8 +606,8 @@ var EventEmitter = class {
 // src/state.ts
 var appData = {};
 var keyRefCounts = {};
-var changedKeys = {};
-var stashedChangedKeys = {};
+var changedKeys = /* @__PURE__ */ new Set();
+var stashedChangedKeys = EMPTY_STRING_SET;
 var dataIsChanged = false;
 var dataWhereSet = {};
 var emitter = new EventEmitter();
@@ -569,7 +618,7 @@ function markBooted() {
 function setupKeysRef(keys2) {
   const keyList = keys2.split(",");
   for (const key of keyList) {
-    if (has(keyRefCounts, key)) {
+    if (hasOwnProperty(keyRefCounts, key)) {
       keyRefCounts[key]++;
     } else {
       keyRefCounts[key] = 1;
@@ -579,7 +628,7 @@ function setupKeysRef(keys2) {
 }
 function teardownKeysRef(keyList) {
   for (const key of keyList) {
-    if (has(keyRefCounts, key)) {
+    if (hasOwnProperty(keyRefCounts, key)) {
       const count = --keyRefCounts[key];
       if (count <= 0) {
         Reflect.deleteProperty(keyRefCounts, key);
@@ -591,35 +640,14 @@ function teardownKeysRef(keyList) {
     }
   }
 }
-var notifyStarted = 0;
-var notifyList = [];
-var notifyTimer;
+var warnedKeys = /* @__PURE__ */ new Set();
 function clearNotify(key) {
-  for (let i = notifyList.length; i--; ) {
-    if (notifyList[i]?.key === key) {
-      notifyList.splice(i, 1);
-    }
-  }
-}
-function doNotify() {
-  const locker = {};
-  for (const n of notifyList) {
-    if (!locker[n.key]) {
-      console.warn(n.message);
-      locker[n.key] = 1;
-    }
-  }
-  notifyList.length = 0;
-  notifyStarted = 0;
+  warnedKeys.delete(key);
 }
 function delayNotify(key, message) {
-  clearTimeout(notifyTimer);
-  notifyStarted = 0;
-  notifyList.push({ key, message });
-  if (!notifyStarted) {
-    notifyStarted = 1;
-    notifyTimer = setTimeout(doNotify, 500);
-  }
+  if (warnedKeys.has(key)) return;
+  warnedKeys.add(key);
+  console.warn(message);
 }
 var State = {
   /**
@@ -631,7 +659,7 @@ var State = {
       return safeguard(
         result,
         (dataKey) => {
-          if (booted && has(dataWhereSet, dataKey) && dataWhereSet[dataKey] !== window.location.pathname) {
+          if (booted && hasOwnProperty(dataWhereSet, dataKey) && dataWhereSet[dataKey] !== window.location.pathname) {
             console.warn(
               `beware! You get state:"{State}.${dataKey}" where it set by page:${dataWhereSet[dataKey]}`
             );
@@ -652,7 +680,7 @@ var State = {
    * Set data to state.
    */
   set(data, excludes) {
-    dataIsChanged = setData(data, appData, changedKeys, excludes || /* @__PURE__ */ new Set()) || dataIsChanged;
+    dataIsChanged = setData(data, appData, changedKeys, excludes || EMPTY_STRING_SET) || dataIsChanged;
     if (typeof window.__lark_Debug !== "undefined" && window.__lark_Debug && booted) {
       for (const p in data) {
         dataWhereSet[p] = window.location.pathname;
@@ -669,26 +697,19 @@ var State = {
     }
     if (dataIsChanged) {
       if (typeof window.__lark_Debug !== "undefined" && window.__lark_Debug) {
-        for (const p in changedKeys) {
-          if (has(changedKeys, p)) {
-            clearNotify(p);
-          }
+        for (const p of changedKeys) {
+          clearNotify(p);
         }
       }
       dataIsChanged = false;
-      const keys2 = {};
-      for (const k in changedKeys) {
-        if (has(changedKeys, k)) {
-          keys2[k] = 1;
-        }
-      }
+      const keys2 = changedKeys;
       stashedChangedKeys = keys2;
-      changedKeys = {};
-      emitter.fire(ROUTER_EVENTS.CHANGED, { keys: keys2 });
+      changedKeys = /* @__PURE__ */ new Set();
+      emitter.fire(RouterEvents.CHANGED, { keys: keys2 });
     }
   },
   /**
-   * Get diff of what changed in last digest.
+   * Get the set of keys changed in the most recent digest.
    */
   diff() {
     return stashedChangedKeys;
@@ -746,6 +767,7 @@ var cachedDefaultPath;
 var cachedRewrite;
 var defaultTitle;
 var frameworkConfig;
+var beforeEachGuards = [];
 function createEmptyLocation() {
   return {
     href: "",
@@ -900,7 +922,7 @@ var Router = {
         document.title = defaultTitle || document.title;
       }
       emitter2.fire(
-        ROUTER_EVENTS.CHANGED,
+        RouterEvents.CHANGED,
         lastChanged
       );
     }
@@ -933,16 +955,16 @@ var Router = {
     }
     const lPath = lastLocation["path"] || "";
     const lParams = lastLocation["params"];
-    const lQuery = {};
+    const lQuery = /* @__PURE__ */ new Set();
     for (const k in lastLocation.query["params"]) {
-      if (has(lastLocation.query["params"], k)) {
-        lQuery[k] = 1;
+      if (hasOwnProperty(lastLocation.query["params"], k)) {
+        lQuery.add(k);
       }
     }
     if (tPath) {
-      if (!has(window, "history")) {
-        for (const qKey in lQuery) {
-          if (has(lQuery, qKey) && !has(tParams, qKey)) {
+      if (!hasOwnProperty(window, "history")) {
+        for (const qKey of lQuery) {
+          if (!hasOwnProperty(tParams, qKey)) {
             tParams[qKey] = "";
           }
         }
@@ -951,14 +973,17 @@ var Router = {
       tPath = lPath;
       tParams = assign({}, lParams, tParams);
     }
-    updateUrl(
-      tPath,
-      tParams,
-      lastLocation,
-      replace,
-      silentFlag,
-      lQuery
-    );
+    updateUrl(tPath, tParams, lastLocation, replace, silentFlag, lQuery);
+  },
+  /**
+   * Register an async-friendly navigation guard. See `RouterInterface.beforeEach`.
+   */
+  beforeEach(guard) {
+    beforeEachGuards.push(guard);
+    return () => {
+      const idx = beforeEachGuards.indexOf(guard);
+      if (idx !== -1) beforeEachGuards.splice(idx, 1);
+    };
   },
   /**
    * Join multiple path segments into a single path.
@@ -1022,12 +1047,39 @@ var Router = {
           }
         };
         Router.fire(
-          ROUTER_EVENTS.CHANGE,
+          RouterEvents.CHANGE,
           changeEvent
         );
-        if (!suspend && !changeEvent.p) {
+        if (suspend || changeEvent.p) {
+          return;
+        }
+        if (beforeEachGuards.length === 0) {
           changeEvent.resolve();
+          return;
         }
+        const from = lastLocation;
+        const to = loc;
+        const guards = beforeEachGuards.slice();
+        let chain = Promise.resolve(true);
+        for (const guard of guards) {
+          chain = chain.then((prev) => {
+            if (prev === false) return false;
+            return guard(to, from);
+          });
+        }
+        chain.then(
+          (result) => {
+            if (changeEvent.p) return;
+            if (result === false) {
+              changeEvent.reject();
+            } else {
+              changeEvent.resolve();
+            }
+          },
+          () => {
+            if (!changeEvent.p) changeEvent.reject();
+          }
+        );
       }
     };
     Router.notify = watchChange;
@@ -1035,7 +1087,7 @@ var Router = {
     window.addEventListener("popstate", watchChange);
     window.addEventListener("beforeunload", (domEvent) => {
       const data = {};
-      Router.fire(ROUTER_EVENTS.PAGE_UNLOAD, data);
+      Router.fire(RouterEvents.PAGE_UNLOAD, data);
       const msg = data["msg"];
       if (msg) {
         domEvent.returnValue = msg;
@@ -1081,13 +1133,17 @@ function parseEventInfo(eventInfo) {
 }
 function findFrameInfo(current, eventType) {
   const eventInfos = [];
-  let begin = current;
   const info = current.getAttribute(`@${eventType}`);
+  const hasSelectorEvents = !!selectorEvents[eventType];
+  if (!info && !hasSelectorEvents) {
+    return eventInfos;
+  }
+  let begin = current;
   let match;
   if (info) {
     match = parseEventInfo(info);
   }
-  if (match && !match.id || selectorEvents[eventType]) {
+  if (match && !match.id || hasSelectorEvents) {
     let selectorFrameId = "#";
     let backtrace = 0;
     while (begin && begin !== document.body) {
@@ -1260,7 +1316,7 @@ var EventDelegator = {
 };
 
 // src/vdom.ts
-var WrapMeta = {
+var wrapMeta = {
   option: [1, "<select multiple>"],
   thead: [1, "<table>"],
   col: [2, "<table><colgroup>"],
@@ -1272,9 +1328,9 @@ var WrapMeta = {
   math: [1, '<math xmlns="' + MATH_NS + '">'],
   _: [0, ""]
 };
-WrapMeta["optgroup"] = WrapMeta["option"];
-WrapMeta["tbody"] = WrapMeta["tfoot"] = WrapMeta["colgroup"] = WrapMeta["caption"] = WrapMeta["thead"];
-WrapMeta["th"] = WrapMeta["td"];
+wrapMeta["optgroup"] = wrapMeta["option"];
+wrapMeta["tbody"] = wrapMeta["tfoot"] = wrapMeta["colgroup"] = wrapMeta["caption"] = wrapMeta["thead"];
+wrapMeta["th"] = wrapMeta["td"];
 var VDoc = document.implementation.createHTMLDocument("");
 var VBase = VDoc.createElement("base");
 VBase.href = document.location.href;
@@ -1285,16 +1341,12 @@ var VDomSpecials = {
   OPTION: ["selected"]
 };
 function vdomUnmountFrames(frame, node) {
-  if (node.nodeType === 1) {
-    const el = node;
-    const id = el.getAttribute("id");
-    if (id) {
-      frame.unmountZone(id);
-      const children = frame.children();
-      if (children.includes(id)) {
-        frame.unmountFrame(id);
-      }
-    }
+  if (!(node instanceof Element)) return;
+  const id = node.getAttribute("id");
+  if (!id) return;
+  frame.unmountZone(id);
+  if (frame.children().includes(id)) {
+    frame.unmountFrame(id);
   }
 }
 function vdomGetNode(html, refNode) {
@@ -1309,7 +1361,7 @@ function vdomGetNode(html, refNode) {
     const match = TAG_NAME_REGEXP.exec(html);
     tag = match ? match[1] : "";
   }
-  const wrap = WrapMeta[tag] || WrapMeta["_"];
+  const wrap = wrapMeta[tag] || wrapMeta["_"];
   tmp.innerHTML = wrap[1] + html;
   let j = wrap[0];
   while (j--) {
@@ -1326,7 +1378,7 @@ function vdomGetCompareKey(node) {
   }
   let key = el.autoId ? "" : el.getAttribute("id") || void 0;
   if (!key) {
-    key = el.getAttribute(LARK_KEYS.DIFF_KEY) || void 0;
+    key = el.getAttribute(LarkInnerKeys.DIFF_KEY) || void 0;
   }
   if (!key) {
     const larkView = el.getAttribute(LARK_VIEW);
@@ -1339,8 +1391,7 @@ function vdomGetCompareKey(node) {
   return key;
 }
 function vdomSpecialDiff(oldNode, newNode) {
-  const nodeName = oldNode.nodeName;
-  const specials = VDomSpecials[nodeName];
+  const specials = VDomSpecials[oldNode.nodeName];
   if (!specials) return 0;
   const oldEl = oldNode;
   const newEl = newNode;
@@ -1389,13 +1440,17 @@ function vdomSetChildNodes(oldParent, newParent, ref, frame, keys_) {
   let oldNode = oldParent.lastChild;
   let newNode = newParent.firstChild;
   let extra = 0;
-  const keyedNodes = {};
-  const newKeyedNodes = {};
+  const keyedNodes = /* @__PURE__ */ new Map();
+  const newKeyedNodes = /* @__PURE__ */ new Map();
   while (oldNode) {
     extra++;
     const nodeKey = vdomGetCompareKey(oldNode);
     if (nodeKey) {
-      const bucket = keyedNodes[nodeKey] || (keyedNodes[nodeKey] = []);
+      let bucket = keyedNodes.get(nodeKey);
+      if (!bucket) {
+        bucket = [];
+        keyedNodes.set(nodeKey, bucket);
+      }
       bucket.push(oldNode);
     }
     oldNode = oldNode.previousSibling;
@@ -1403,7 +1458,7 @@ function vdomSetChildNodes(oldParent, newParent, ref, frame, keys_) {
   while (newNode) {
     const nodeKey = vdomGetCompareKey(newNode);
     if (nodeKey) {
-      newKeyedNodes[nodeKey] = (newKeyedNodes[nodeKey] || 0) + 1;
+      newKeyedNodes.set(nodeKey, (newKeyedNodes.get(nodeKey) ?? 0) + 1);
     }
     newNode = newNode.nextSibling;
   }
@@ -1414,23 +1469,25 @@ function vdomSetChildNodes(oldParent, newParent, ref, frame, keys_) {
     const tempNew = newNode;
     newNode = newNode.nextSibling;
     const nodeKey = vdomGetCompareKey(tempNew);
-    let foundNode = nodeKey ? keyedNodes[nodeKey] : void 0;
+    let foundNode = nodeKey ? keyedNodes.get(nodeKey) : void 0;
     if (foundNode && (foundNode = foundNode.slice()) && foundNode.length) {
       const matched = foundNode.pop();
       while (matched !== oldNode) {
-        const next = oldNode?.nextSibling ?? null;
+        if (!oldNode) break;
+        const next = oldNode.nextSibling;
         oldParent.appendChild(oldNode);
         oldNode = next;
       }
       oldNode = matched.nextSibling;
-      if (nodeKey && newKeyedNodes[nodeKey]) {
-        newKeyedNodes[nodeKey]--;
+      if (nodeKey) {
+        const c = newKeyedNodes.get(nodeKey);
+        if (c) newKeyedNodes.set(nodeKey, c - 1);
       }
       vdomSetNode(matched, tempNew, oldParent, ref, frame, keys_);
     } else if (oldNode) {
       const tempOld2 = oldNode;
       const oldKey = vdomGetCompareKey(tempOld2);
-      if (oldKey && keyedNodes[oldKey] && newKeyedNodes[oldKey]) {
+      if (oldKey && keyedNodes.has(oldKey) && newKeyedNodes.get(oldKey)) {
         extra++;
         ref.hasChanged = 1;
         ref.domOps.push([8, oldParent, tempNew, tempOld2]);
@@ -1454,17 +1511,21 @@ function vdomSetChildNodes(oldParent, newParent, ref, frame, keys_) {
   }
 }
 function vdomSetNode(oldNode, newNode, oldParent, ref, frame, keys_) {
-  if (vdomSpecialDiff(oldNode, newNode) || oldNode.nodeType === 1 && oldNode.hasAttribute(LARK_KEYS.VIEW_KEY) || !(oldNode.isEqualNode && oldNode.isEqualNode(newNode))) {
+  const oldAsEl = oldNode instanceof Element ? oldNode : null;
+  const newAsEl = newNode instanceof Element ? newNode : null;
+  const hasViewKey = !!oldAsEl?.hasAttribute(LarkInnerKeys.VIEW_KEY);
+  const equalAsNodes = oldAsEl !== null && newAsEl !== null && oldAsEl.isEqualNode && oldAsEl.isEqualNode(newAsEl);
+  if (vdomSpecialDiff(oldNode, newNode) || hasViewKey || !equalAsNodes) {
     if (oldNode.nodeType === newNode.nodeType && oldNode.nodeName === newNode.nodeName) {
-      if (oldNode.nodeType === 1) {
-        const oldEl = oldNode;
-        const newEl = newNode;
-        const staticKey = newEl.getAttribute(LARK_KEYS.DIFF_KEY);
-        if (staticKey && staticKey === oldEl.getAttribute(LARK_KEYS.DIFF_KEY)) {
+      if (oldAsEl !== null && newAsEl !== null) {
+        const oldEl = oldAsEl;
+        const newEl = newAsEl;
+        const staticKey = newEl.getAttribute(LarkInnerKeys.DIFF_KEY);
+        if (staticKey && staticKey === oldEl.getAttribute(LarkInnerKeys.DIFF_KEY)) {
           return;
         }
         const newLarkView = newEl.getAttribute(LARK_VIEW);
-        const updateAttribute = !newEl.getAttribute(LARK_KEYS.ATTR_KEY) || newEl.getAttribute(LARK_KEYS.ATTR_KEY) !== oldEl.getAttribute(LARK_KEYS.ATTR_KEY);
+        const updateAttribute = !newEl.getAttribute(LarkInnerKeys.ATTR_KEY) || newEl.getAttribute(LarkInnerKeys.ATTR_KEY) !== oldEl.getAttribute(LarkInnerKeys.ATTR_KEY);
         let updateChildren = true;
         if (newLarkView) {
           const oldFrameId = oldEl.getAttribute("id") || "";
@@ -1565,7 +1626,8 @@ function encodeQ(v) {
 }
 
 // src/updater.ts
-function updaterRef(refData, value, key) {
+function updaterRef(refDataIn, value, key) {
+  const refData = refDataIn;
   const counter = refData[SPLITTER];
   for (let i = counter; --i; ) {
     key = SPLITTER + i;
@@ -1585,13 +1647,19 @@ var Updater = class {
   /** Ref data for template rendering */
   refData;
   /** Changed keys in current digest cycle */
-  changedKeys = {};
+  changedKeys = /* @__PURE__ */ new Set();
   /** Whether data has changed since last digest */
   hasChangedFlag = 0;
-  /** Digesting queue: supports re-digest during digest */
+  /**
+   * Digesting queue: supports re-digest during digest.
+   * Holds pending callbacks; `null` is used as a sentinel marking the start
+   * of an active digest cycle, so `runDigest` can detect re-entrant calls.
+   */
   digestingQueue = [];
-  /** Snapshot JSON string for altered() detection */
-  snapshotJson;
+  /** Monotonically increasing version, bumped each time data actually changes. */
+  version = 0;
+  /** Snapshot of `version` taken by `snapshot()`, used by `altered()`. */
+  snapshotVersion;
   constructor(viewId) {
     this.viewId = viewId;
     this.data = { vId: viewId };
@@ -1619,7 +1687,16 @@ var Updater = class {
    * Returns this for chaining.
    */
   set(data, excludes) {
-    this.hasChangedFlag = setData(data, this.data, this.changedKeys, excludes || /* @__PURE__ */ new Set()) || this.hasChangedFlag ? 1 : 0;
+    const changed = setData(
+      data,
+      this.data,
+      this.changedKeys,
+      excludes || EMPTY_STRING_SET
+    );
+    if (changed) {
+      this.version++;
+      this.hasChangedFlag = 1;
+    }
     return this;
   }
   /**
@@ -1655,13 +1732,13 @@ var Updater = class {
     const keys2 = this.changedKeys;
     const changed = this.hasChangedFlag;
     this.hasChangedFlag = 0;
-    this.changedKeys = {};
+    this.changedKeys = /* @__PURE__ */ new Set();
     const frame = Frame.get(this.viewId);
     const view = frame?.view;
     const node = getById(this.viewId);
-    if (changed && view && node && view.signature > 0) {
+    if (changed && view && node && view.signature > 0 && frame) {
       const template = view.template;
-      if (template && typeof template === "function") {
+      if (typeof template === "function") {
         const html = template(
           this.data,
           this.viewId,
@@ -1698,43 +1775,65 @@ var Updater = class {
     }
   }
   /**
-   * Save a snapshot of current data for altered() detection.
+   * Save a snapshot of the current data version for `altered()` detection.
+   * Cheap O(1) — records the current monotonic version, no serialization.
    */
   snapshot() {
-    this.snapshotJson = JSON.stringify(this.data);
+    this.snapshotVersion = this.version;
     return this;
   }
   /**
-   * Check if data has changed since last snapshot.
+   * Check whether data has changed since the last snapshot.
+   * Returns undefined when no snapshot has been taken yet.
    */
   altered() {
-    if (this.snapshotJson) {
-      return this.snapshotJson !== JSON.stringify(this.data);
-    }
-    return void 0;
+    if (this.snapshotVersion === void 0) return void 0;
+    return this.version !== this.snapshotVersion;
   }
   /**
-   * Translate data references (SPLITTER-prefixed values).
+   * Translate a refData reference back to its original value.
+   *
+   * The ref protocol is `SPLITTER` + ascii decimal digits — the exact format
+   * emitted by `updaterRef`. We require that exact shape so a user-supplied
+   * string that merely begins with SPLITTER is never accidentally resolved
+   * (or mishandled as a "missing ref").
    */
   translate(data) {
-    if (typeof data === "string" && data[0] === SPLITTER) {
-      return has(this.refData, data) ? this.refData[data] : data;
+    if (typeof data !== "string") return data;
+    if (data.length < 2 || data[0] !== SPLITTER) return data;
+    for (let i = 1; i < data.length; i++) {
+      const c = data.charCodeAt(i);
+      if (c < 48 || c > 57) return data;
     }
-    return data;
+    return hasOwnProperty(this.refData, data) ? this.refData[data] : data;
   }
   /**
-   * Parse expression with data context.
+   * Resolve a dotted property path against refData.
+   *
+   * Only safe property-path syntax is supported: `a`, `a.b`, `a.b.c`.
+   * Numeric literals (e.g. `1`, `1.5`) are returned as numbers. Anything else
+   * returns `undefined` — we no longer evaluate arbitrary JavaScript via
+   * `new Function`, so the method is CSP-safe and cannot be used as an
+   * injection vector.
    */
   parse(expr) {
-    try {
-      const fn = new Function("data", `with(data) { return ${expr}; }`);
-      return fn(this.refData);
-    } catch {
+    const trimmed = expr.trim();
+    if (!trimmed) return void 0;
+    if (/^-?\d+(?:\.\d+)?$/.test(trimmed)) {
+      return Number(trimmed);
+    }
+    if (!/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*$/.test(trimmed)) {
       return void 0;
     }
+    let cur = this.refData;
+    for (const segment of trimmed.split(".")) {
+      if (cur == null || typeof cur !== "object") return void 0;
+      cur = cur[segment];
+    }
+    return cur;
   }
   /**
-   * Get changed keys (for external inspection).
+   * Get the set of keys changed since the last digest (for external inspection).
    */
   getChangedKeys() {
     return this.changedKeys;
@@ -1781,30 +1880,31 @@ var View = class _View {
   // ============================================================
   // 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() {
-    const proto = Object.getPrototypeOf(this);
-    return proto["$evtObjMap"] || {};
+    return this.protoEventState.$evtObjMap ?? {};
   }
   /**
    * Selector event map: eventType -> selector list.
    * Read from prototype ($selMap) set by View.prepare.
    */
   get eventSelectorMap() {
-    const proto = Object.getPrototypeOf(this);
-    return proto["$selMap"] || {};
+    return this.protoEventState.$selMap ?? {};
   }
   /**
    * Global event list: [{handler, element, eventName, modifiers}].
    * Read from prototype ($globalEvtList) set by View.prepare.
    */
   get globalEventList() {
-    const proto = Object.getPrototypeOf(this);
-    return proto["$globalEvtList"] || [];
+    return this.protoEventState.$globalEvtList ?? [];
   }
   // ============================================================
   // Instance lifecycle methods
@@ -1839,13 +1939,17 @@ var View = class _View {
   // ============================================================
   // Update methods
   // ============================================================
+  /** Get the owning frame, asserting it has been bound. */
+  get ownerFrame() {
+    return this.owner;
+  }
   /**
    * 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.owner.unmountZone(id, true);
+      this.ownerFrame.unmountZone(id, true);
     }
   }
   /**
@@ -1863,7 +1967,7 @@ var View = class _View {
         this.endUpdatePending = 1;
         this.rendered = true;
       }
-      const ownerFrame = this.owner;
+      const ownerFrame = this.ownerFrame;
       ownerFrame.mountZone(updateId, inner);
       if (!flag) {
         setTimeout(
@@ -1902,11 +2006,12 @@ var View = class _View {
     const loc = this.locationObserved;
     loc.flag = 1;
     if (typeof params === "object" && !Array.isArray(params)) {
-      if (params["path"]) {
+      const opts = params;
+      if (opts["path"]) {
         observePath = true;
       }
-      const paramKeys = params["params"];
-      if (paramKeys) {
+      const paramKeys = opts["params"];
+      if (typeof paramKeys === "string" || Array.isArray(paramKeys)) {
         params = paramKeys;
       }
     }
@@ -1970,24 +2075,16 @@ var View = class _View {
    */
   leaveTip(message, condition) {
     const changeListener = function(e) {
-      const isRouterChange = e.type === ROUTER_EVENTS.CHANGE;
+      const isRouterChange = e.type === RouterEvents.CHANGE;
       const aKey = isRouterChange ? "a" : "b";
       const bKey = isRouterChange ? "b" : "a";
       if (changeListener[aKey]) {
-        if (typeof e.prevent === "function") {
-          e.prevent();
-        }
-        if (typeof e.reject === "function") {
-          e.reject();
-        }
+        e.prevent?.();
+        e.reject?.();
       } else if (condition()) {
-        if (typeof e.prevent === "function") {
-          e.prevent();
-        }
+        e.prevent?.();
         changeListener[bKey] = 1;
-        if (typeof e.resolve === "function") {
-          e.resolve();
-        }
+        e.resolve?.();
       }
     };
     const unloadListener = (e) => {
@@ -1995,14 +2092,12 @@ var View = class _View {
         e["msg"] = message;
       }
     };
-    const changeFn = changeListener;
-    const unloadFn = unloadListener;
-    Router.on(ROUTER_EVENTS.CHANGE, changeFn);
-    Router.on(ROUTER_EVENTS.PAGE_UNLOAD, unloadFn);
-    this.on("unload", changeFn);
+    Router.on(RouterEvents.CHANGE, changeListener);
+    Router.on(RouterEvents.PAGE_UNLOAD, unloadListener);
+    this.on("unload", changeListener);
     this.on("destroy", () => {
-      Router.off(ROUTER_EVENTS.CHANGE, changeFn);
-      Router.off(ROUTER_EVENTS.PAGE_UNLOAD, unloadFn);
+      Router.off(RouterEvents.CHANGE, changeListener);
+      Router.off(RouterEvents.PAGE_UNLOAD, unloadListener);
     });
   }
   // ============================================================
@@ -2032,7 +2127,7 @@ var View = class _View {
       _View.mergeMixins(mixins, oView, ctors);
     }
     for (const p in proto) {
-      if (!has(proto, p)) continue;
+      if (!hasOwnProperty(proto, p)) continue;
       const currentFn = proto[p];
       if (typeof currentFn !== "function") continue;
       const matches = p.match(VIEW_EVENT_METHOD_REGEXP);
@@ -2078,16 +2173,16 @@ var View = class _View {
         const existingFn = proto[combinedKey];
         if (!existingFn) {
           proto[combinedKey] = currentFn;
-        } else {
+        } else if (typeof existingFn === "function") {
           const mixinFn = currentFn;
           const existingMixin = existingFn;
           if (existingMixin.marker) {
             if (mixinFn.marker) {
               proto[combinedKey] = _View.processMixinsSameEvent(
-                currentFn,
-                existingFn
+                mixinFn,
+                existingMixin
               );
-            } else if (has(proto, p)) {
+            } else if (hasOwnProperty(proto, p)) {
               proto[combinedKey] = currentFn;
             }
           }
@@ -2110,7 +2205,7 @@ var View = class _View {
     const selectorObject = view.eventSelectorMap;
     const eventsList = view.globalEventList;
     for (const e in eventsObject) {
-      if (has(eventsObject, e)) {
+      if (hasOwnProperty(eventsObject, e)) {
         if (destroy) {
           EventDelegator.unbind(e, !!selectorObject[e]);
         } else {
@@ -2153,7 +2248,7 @@ var View = class _View {
   static destroyAllResources(view, lastly) {
     const cache = view.resources;
     for (const p in cache) {
-      if (has(cache, p)) {
+      if (hasOwnProperty(cache, p)) {
         const entry = cache[p];
         if (lastly || entry.destroyOnRender) {
           _View.destroyResource(cache, p, true);
@@ -2183,13 +2278,16 @@ var View = class _View {
   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 instanceFn = typeof this[fnName] === "function" ? this[fnName] : originalFn;
-        const fnToCall = instanceFn === wrapped ? originalFn : instanceFn;
+        const lookup = 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;
@@ -2203,19 +2301,18 @@ var View = class _View {
    */
   static processMixinsSameEvent(additional, exist) {
     let temp;
-    const existMixin = exist;
-    if (existMixin.handlerList) {
-      temp = existMixin;
+    if (exist.handlerList) {
+      temp = exist;
     } else {
-      temp = function(...e) {
-        funcWithTry(temp.handlerList ?? [], e, this, noop);
+      const merged = function(...e) {
+        funcWithTry(merged.handlerList ?? [], e, this, noop);
       };
-      temp.handlerList = [exist];
-      temp.marker = 1;
+      merged.handlerList = [exist];
+      merged.marker = 1;
+      temp = merged;
     }
-    const additionalMixin = additional;
     temp.handlerList = (temp.handlerList ?? []).concat(
-      additionalMixin.handlerList ?? [additional]
+      additional.handlerList ?? [additional]
     );
     return temp;
   }
@@ -2227,29 +2324,29 @@ var View = class _View {
     const temp = {};
     for (const node of mixins) {
       for (const p in node) {
-        if (!has(node, p)) continue;
+        if (!hasOwnProperty(node, p)) continue;
         const fn = node[p];
+        if (typeof fn !== "function") continue;
+        const mixinFn = fn;
         const exist = temp[p];
         if (p === "make") {
-          ctors.push(fn);
+          ctors.push(mixinFn);
           continue;
         }
         if (VIEW_EVENT_METHOD_REGEXP.test(p)) {
           if (exist) {
-            temp[p] = _View.processMixinsSameEvent(fn, exist);
+            temp[p] = _View.processMixinsSameEvent(mixinFn, exist);
           } else {
-            fn.marker = 1;
-            temp[p] = fn;
-          }
-        } else {
-          if (!exist) {
-            temp[p] = fn;
+            mixinFn.marker = 1;
+            temp[p] = mixinFn;
           }
+        } else if (!exist) {
+          temp[p] = mixinFn;
         }
       }
     }
     for (const p in temp) {
-      if (!has(proto, p)) {
+      if (!hasOwnProperty(proto, p)) {
         proto[p] = temp[p];
       }
     }
@@ -2282,19 +2379,20 @@ var View = class _View {
    * - Event method patterns: `'name<click>'` etc.
    */
   static extend(props, statics) {
-    props = props || {};
-    const make = props["make"];
+    const definedProps = props ?? {};
+    const make = definedProps["make"];
     const ctors = [];
-    if (make) {
+    if (typeof make === "function") {
       ctors.push(make);
     }
     const ParentView = this;
     const ChildView = class extends ParentView {
       constructor(nodeId, ownerFrame, initParams, node, mixinCtors) {
         super(nodeId, ownerFrame, initParams, node, []);
-        for (const key in props) {
-          if (has(props, key) && key !== "make" && key !== "render") {
-            this[key] = props[key];
+        const instanceProps = this;
+        for (const key in definedProps) {
+          if (hasOwnProperty(definedProps, key) && key !== "make" && key !== "render") {
+            instanceProps[key] = definedProps[key];
           }
         }
         this.id = nodeId;
@@ -2314,15 +2412,16 @@ var View = class _View {
       }
     };
     const proto = ChildView.prototype;
-    for (const key in props) {
-      if (has(props, key) && key !== "make") {
-        proto[key] = props[key];
+    for (const key in definedProps) {
+      if (hasOwnProperty(definedProps, key) && key !== "make") {
+        proto[key] = definedProps[key];
       }
     }
     if (statics) {
+      const staticTarget = ChildView;
       for (const key in statics) {
-        if (has(statics, key)) {
-          ChildView[key] = statics[key];
+        if (hasOwnProperty(statics, key)) {
+          staticTarget[key] = statics[key];
         }
       }
     }
@@ -2337,14 +2436,86 @@ var View = class _View {
     return this;
   }
 };
+function defineView(props, statics) {
+  return View.extend(props, statics);
+}
+
+// src/module-loader.ts
+var config = {
+  rootId: "root",
+  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/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 invalidateViewClass(viewPath) {
+  const parsed = parseUri(viewPath);
+  const path = parsed.path;
+  if (path) {
+    Reflect.deleteProperty(viewClassRegistry, path);
+  }
+}
+function getViewClassRegistry() {
+  return viewClassRegistry;
+}
 
 // src/frame.ts
 var frameRegistry = /* @__PURE__ */ new Map();
 var rootFrame;
 var globalAlter;
+var MAX_FRAME_POOL = 64;
 var frameCache = [];
 var staticEmitter = new EventEmitter();
-var viewClassRegistry = {};
 var Frame = class _Frame extends EventEmitter {
   /** Frame ID (same as owner DOM element ID) */
   id;
@@ -2359,8 +2530,8 @@ var Frame = class _Frame extends EventEmitter {
   childrenCount = 0;
   /** Ready count (children that have fired 'created') */
   readyCount = 0;
-  /** Ready map: id -> 1 */
-  readyMap = {};
+  /** Set of child frame IDs that have fired 'created' */
+  readyMap = /* @__PURE__ */ new Set();
   /** View instance */
   viewInstance;
   /** Get view instance (read-only) */
@@ -2431,13 +2602,30 @@ var Frame = class _Frame extends EventEmitter {
     this.viewPath = viewPath;
     const params = parsed["params"];
     translateQuery(pId || this.id, viewPath, params);
+    const initParams = { ...params };
     if (viewInitParams) {
-      assign(params, viewInitParams);
+      assign(initParams, viewInitParams);
     }
     const sign = this.signature;
-    if (viewClassRegistry[viewClassName]) {
-      this.doMountView(viewClassRegistry[viewClassName], params, node, sign);
+    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);
+        }
+      }
+    });
   }
   /**
    * Internal: actually mount the view after class is loaded.
@@ -2445,14 +2633,8 @@ var Frame = class _Frame extends EventEmitter {
   doMountView(ViewClass, params, node, sign) {
     if (sign !== this.signature) return;
     const mixinCtors = View.prepare(ViewClass);
-    const ViewConstructor = ViewClass;
-    const view = new ViewConstructor(
-      this.id,
-      this,
-      params,
-      node,
-      mixinCtors
-    );
+    const Ctor = ViewClass;
+    const view = new Ctor(this.id, this, params, node, mixinCtors);
     this.viewInstance = view;
     view.signature = 1;
     View.delegateEvents(view);
@@ -2533,7 +2715,9 @@ var Frame = class _Frame extends EventEmitter {
     frame.unmountView();
     removeFrame(targetId, wasCreated);
     reInitFrameForCache(frame);
-    frameCache.push(frame);
+    if (frameCache.length < MAX_FRAME_POOL) {
+      frameCache.push(frame);
+    }
     const parent = frameRegistry.get(pId || "");
     if (parent && parent.childrenMap[targetId]) {
       Reflect.deleteProperty(parent.childrenMap, targetId);
@@ -2552,13 +2736,12 @@ var Frame = class _Frame extends EventEmitter {
     const viewElements = rootEl.querySelectorAll(`[${LARK_VIEW}]`);
     const frames = [];
     viewElements.forEach((el) => {
-      const htmlEl = el;
-      if (!htmlEl.frameBound) {
-        const elId = ensureElementId2(htmlEl);
-        htmlEl.frameBound = 1;
-        const viewPath = getAttribute(htmlEl, LARK_VIEW);
-        frames.push([elId, viewPath]);
-      }
+      if (!(el instanceof HTMLElement)) return;
+      if (htmlElIsBound(el)) return;
+      const elId = ensureElementId2(el);
+      el.frameBound = 1;
+      const viewPath = getAttribute(el, LARK_VIEW);
+      frames.push([elId, viewPath]);
     });
     for (const [frameId, viewPath] of frames) {
       this.mountFrame(frameId, viewPath);
@@ -2571,7 +2754,7 @@ var Frame = class _Frame extends EventEmitter {
    */
   unmountZone(zoneId, _inner) {
     for (const childId in this.childrenMap) {
-      if (has(this.childrenMap, childId)) {
+      if (hasOwnProperty(this.childrenMap, childId)) {
         if (!zoneId || childId !== zoneId) {
           this.unmountFrame(childId);
         }
@@ -2585,7 +2768,7 @@ var Frame = class _Frame extends EventEmitter {
   children() {
     const result = [];
     for (const id in this.childrenMap) {
-      if (has(this.childrenMap, id)) {
+      if (hasOwnProperty(this.childrenMap, id)) {
         result.push(id);
       }
     }
@@ -2612,14 +2795,10 @@ var Frame = class _Frame extends EventEmitter {
     let result;
     const view = this.view;
     if (view && view.rendered) {
-      const fn = view[name];
+      const lookup = view;
+      const fn = lookup[name];
       if (typeof fn === "function") {
-        result = funcWithTry(
-          fn,
-          args || [],
-          view,
-          noop
-        );
+        result = funcWithTry(fn, args || [], view, noop);
       }
     } else {
       const key = SPLITTER + name;
@@ -2642,6 +2821,25 @@ var Frame = class _Frame extends EventEmitter {
     }
     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);
+  }
   // ============================================================
   // Static methods
   // ============================================================
@@ -2653,8 +2851,25 @@ var Frame = class _Frame extends EventEmitter {
   static getAll() {
     return frameRegistry;
   }
-  /** Get or create root frame */
-  static root(rootId) {
+  /**
+   * Returns the existing root frame, or `undefined` if none has been created.
+   * Pure getter — never creates a Frame, never touches the DOM.
+   *
+   * Use `Frame.createRoot(id)` to create the root explicitly during framework
+   * boot. For Micro-Frontend hosts that own multiple independent containers,
+   * use `new Frame(containerId)` directly so each MF mount has its own root.
+   */
+  static getRoot() {
+    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.
+   */
+  static createRoot(rootId) {
     if (!rootFrame) {
       rootId = rootId || "root";
       let rootElement = document.getElementById(rootId);
@@ -2666,6 +2881,17 @@ var Frame = class _Frame extends EventEmitter {
     }
     return rootFrame;
   }
+  /**
+   * @deprecated Use `Frame.getRoot()` for read-only access or
+   * `Frame.createRoot(id)` to create the root explicitly. The single-method
+   * `root()` blurred the distinction and was a common source of bugs in
+   * Micro-Frontend hosts.
+   *
+   * Kept for backward compatibility — behavior unchanged.
+   */
+  static root(rootId) {
+    return _Frame.createRoot(rootId);
+  }
   /** Bind event listener (static) */
   static on(event, handler) {
     staticEmitter.on(event, handler);
@@ -2681,6 +2907,9 @@ var Frame = class _Frame extends EventEmitter {
     staticEmitter.fire(event, data);
   }
 };
+function htmlElIsBound(element) {
+  return !!element.frameBound;
+}
 function ensureElementId2(element) {
   const id = element.getAttribute("id");
   if (id) return id;
@@ -2710,8 +2939,8 @@ function notifyCreated(frameInstance) {
     const pId = frameInstance.parentId;
     if (pId) {
       const parent = frameRegistry.get(pId);
-      if (parent && !parent.readyMap[frameInstance.id]) {
-        parent.readyMap[frameInstance.id] = 1;
+      if (parent && !parent.readyMap.has(frameInstance.id)) {
+        parent.readyMap.add(frameInstance.id);
         parent.readyCount++;
         notifyCreated(parent);
       }
@@ -2726,9 +2955,9 @@ function notifyAlter(frameInstance, data) {
     const pId = frameInstance.parentId;
     if (pId) {
       const parent = frameRegistry.get(pId);
-      if (parent && parent.readyMap[frameInstance.id]) {
+      if (parent && parent.readyMap.has(frameInstance.id)) {
         parent.readyCount--;
-        Reflect.deleteProperty(parent.readyMap, frameInstance.id);
+        parent.readyMap.delete(frameInstance.id);
         notifyAlter(parent, data);
       }
     }
@@ -2741,7 +2970,7 @@ function reInitFrame(frame, id, parentId) {
   frame["childrenCount"] = 0;
   frame["readyCount"] = 0;
   frame["signature"] = 1;
-  frame["readyMap"] = {};
+  frame["readyMap"] = /* @__PURE__ */ new Set();
   frame["invokeList"] = [];
   frameRegistry.set(id, frame);
 }
@@ -2749,7 +2978,7 @@ function reInitFrameForCache(frame) {
   Reflect.set(frame, "id", "");
   frame["_parentId"] = void 0;
   frame["childrenMap"] = {};
-  frame["readyMap"] = {};
+  frame["readyMap"] = /* @__PURE__ */ new Set();
 }
 function translateQuery(pId, src, params) {
   const parentFrame = frameRegistry.get(pId);
@@ -2759,22 +2988,138 @@ function translateQuery(pId, src, params) {
   if (!parentRefData) return;
   if (src.indexOf(SPLITTER) > 0) {
     translateData(parentRefData, params);
-    if (params[SPLITTER]) {
-      assign(
-        params,
-        params[SPLITTER]
-      );
+    const paramsRec = params;
+    const splitterValue = paramsRec[SPLITTER];
+    if (splitterValue && typeof splitterValue === "object") {
+      assign(params, splitterValue);
       Reflect.deleteProperty(params, SPLITTER);
     }
   }
 }
-function registerViewClass(viewPath, ViewClass) {
-  const parsed = parseUri(viewPath);
-  const path = parsed.path;
-  if (path) {
-    viewClassRegistry[path] = ViewClass;
+
+// 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];
+}
+function resetProjectsMap() {
+  projectsMap = null;
 }
+var skeletonTemplate = (data, viewId) => {
+  let skeletonHtml = "<div>Loading...</div>";
+  if (data && typeof data === "object") {
+    const candidate = data.skeleton;
+    if (typeof candidate === "string") skeletonHtml = candidate;
+  }
+  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"]
+    });
+    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 {
@@ -2962,29 +3307,31 @@ var Service = class {
    * Get metadata for an API endpoint.
    */
   static meta(attrs) {
-    const name = typeof attrs === "string" ? attrs : attrs["name"];
-    return this._metaList[name] || attrs;
+    const name = typeof attrs === "string" ? attrs : String(attrs["name"] ?? "");
+    const known = this._metaList[name];
+    if (known) return known;
+    return attrs;
   }
   /**
    * Create a Payload for an API request.
    */
   static create(attrs) {
     const meta = this.meta(attrs);
-    const cache = attrs["cache"] | 0 || meta.cache || 0;
+    const cache = toCacheValue(attrs["cache"]) || meta.cache || 0;
     const entity = new Payload();
     entity.set(meta);
     entity.cacheInfo = {
       name: meta.name,
-      after: meta.after,
-      cleans: meta.cleanKeys,
+      after: typeof meta.after === "function" ? meta.after : void 0,
+      cleans: typeof meta.cleanKeys === "string" ? meta.cleanKeys : void 0,
       key: cache ? defaultCacheKey(meta, attrs) : "",
       time: 0
     };
-    if (typeof attrs === "object" && attrs !== null) {
+    if (attrs !== null) {
       entity.set(attrs);
     }
     const before = meta.before;
-    if (before) {
+    if (typeof before === "function") {
       funcWithTry(before, [entity], entity, noop);
     }
     this._staticEmitter.fire("begin", { payload: entity });
@@ -3010,7 +3357,7 @@ var Service = class {
    */
   static cached(attrs) {
     const meta = this.meta(attrs);
-    const cache = attrs["cache"] | 0 || meta.cache || 0;
+    const cache = toCacheValue(attrs["cache"]) || meta.cache || 0;
     let cacheKey = "";
     if (cache) {
       cacheKey = defaultCacheKey(meta, attrs);
@@ -3018,7 +3365,8 @@ var Service = class {
     if (cacheKey) {
       const info = this._pendingCacheKeys[cacheKey];
       if (info) {
-        return info.entity;
+        const entity = info.entity;
+        return entity instanceof Payload ? entity : void 0;
       }
       const cached = this._payloadCache.get(cacheKey);
       if (cached && cached.cacheInfo) {
@@ -3035,17 +3383,14 @@ var Service = class {
    * Clear cached payloads by endpoint name.
    */
   static clear(names) {
-    const nameList = (typeof names === "string" ? names : names.join(",")).split(",");
-    const nameSet = {};
-    for (const n of nameList) {
-      nameSet[n] = 1;
-    }
+    const nameSet = new Set(
+      (typeof names === "string" ? names : names.join(",")).split(",")
+    );
     const keysToDelete = [];
     this._payloadCache.forEach((payload) => {
-      if (payload?.cacheInfo && nameSet[payload.cacheInfo.name]) {
-        if (payload.cacheInfo.key) {
-          keysToDelete.push(payload.cacheInfo.key);
-        }
+      const info = payload?.cacheInfo;
+      if (info && info.key && nameSet.has(info.name)) {
+        keysToDelete.push(info.key);
       }
     });
     for (const key of keysToDelete) {
@@ -3064,12 +3409,23 @@ var Service = class {
   }
   /**
    * Create a new Service subclass with a custom sync function.
-   * Each subclass gets its own per-type state (metaList, cache, etc.)
-   * to ensure isolation between different Service types.
+   *
+   * Each subclass gets its OWN copies of every per-type static field
+   * (`_metaList`, `_payloadCache`, `_pendingCacheKeys`, `_syncFn`,
+   * `_staticEmitter`, `_cacheMax`, `_cacheBuffer`) via `static override`.
+   * This is intentional: it ensures that endpoint metadata, cache state,
+   * in-flight dedup keys, and event subscribers are fully isolated between
+   * different Service types, even when one extends another.
+   *
+   * **Do not refactor these `static override` declarations away** — sharing
+   * them through prototype inheritance would let endpoints registered on one
+   * subclass leak into another, and the LFU cache evictions of one type
+   * would race with those of another.
    */
   static extend(newSyncFn, 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,
@@ -3084,18 +3440,34 @@ var Service = class {
     return ChildService;
   }
 };
+var metaJsonCache = /* @__PURE__ */ new WeakMap();
+function getMetaJson(meta) {
+  let cached = metaJsonCache.get(meta);
+  if (cached === void 0) {
+    cached = JSON.stringify(meta);
+    metaJsonCache.set(meta, cached);
+  }
+  return cached;
+}
 function defaultCacheKey(meta, attrs) {
-  return JSON.stringify(attrs) + SPLITTER + JSON.stringify(meta);
+  return JSON.stringify(attrs) + SPLITTER + getMetaJson(meta);
+}
+function toCacheValue(v) {
+  if (typeof v === "number") return v | 0;
+  if (typeof v === "string") {
+    const n = Number(v);
+    return Number.isFinite(n) ? n | 0 : 0;
+  }
+  return 0;
 }
 function serviceSend(service, attrs, done, flag, save) {
-  if (service["destroyed"]) return;
-  if (service["busy"]) {
-    service.enqueue(
-      serviceSend.bind(null, service, attrs, done, flag, save)
-    );
+  if (service.destroyed) return;
+  if (service.busy) {
+    const queued = () => serviceSend(service, attrs, done, flag, save);
+    service.enqueue(queued);
     return;
   }
-  service["busy"] = 1;
+  service.busy = 1;
   let attrList;
   if (typeof attrs === "string") {
     attrList = [{ name: attrs }];
@@ -3120,10 +3492,10 @@ function serviceSend(service, attrs, done, flag, save) {
       newPayload = true;
       staticEmitter2.fire("done", { payload });
     }
-    if (!service["destroyed"]) {
+    if (!service.destroyed) {
       const finish = requestCount === total;
       if (finish) {
-        service["busy"] = 0;
+        service.busy = 0;
         if (flag === FETCH_FLAGS_ALL) {
           doneArr[0] = errorArgs;
           funcWithTry(done, doneArr, service, noop);
@@ -3140,10 +3512,7 @@ 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 = service.type.get(attrObj, save);
     const payloadEntity = payloadInfo.entity;
     const cacheKey = payloadEntity.cacheInfo?.key || "";
     const complete = remoteComplete.bind(null, requestCount++);
@@ -3157,15 +3526,13 @@ function serviceSend(service, attrs, done, flag, save) {
         const cacheComplete = () => {
           const list = pendingCacheKeys[cacheKey];
           const entity = list.entity;
-          if (entity.cacheInfo) {
+          if (entity instanceof Payload && entity.cacheInfo) {
             entity.cacheInfo.time = now();
+            internals.payloadCache.set(cacheKey, entity);
           }
-          internals.payloadCache.set(cacheKey, entity);
           Reflect.deleteProperty(pendingCacheKeys, cacheKey);
           for (const cb of list) {
-            if (typeof cb === "function") {
-              cb();
-            }
+            if (typeof cb === "function") cb();
           }
         };
         syncFn(payloadEntity, cacheComplete);
@@ -3178,12 +3545,14 @@ function serviceSend(service, attrs, done, flag, save) {
   }
 }
 
-// src/frame-visualizer.ts
-var MSG_PING = "LARK_VISUALIZER_PING";
-var MSG_PONG = "LARK_VISUALIZER_PONG";
-var MSG_REQUEST_TREE = "LARK_VISUALIZER_REQUEST_TREE";
-var MSG_TREE = "LARK_VISUALIZER_TREE";
-var MSG_TREE_DELTA = "LARK_VISUALIZER_TREE_DELTA";
+// src/frame-visual.ts
+var FrameVisualBridge = {
+  MSG_PING: "LARK_VIS_PING",
+  MSG_PONG: "LARK_VIS_PONG",
+  MSG_REQUEST_TREE: "LARK_VIS_REQUEST_TREE",
+  MSG_TREE: "LARK_VIS_TREE",
+  MSG_TREE_DELTA: "LARK_VIS_TREE_DELTA"
+};
 function serializeView(view) {
   return {
     id: view.id,
@@ -3223,7 +3592,10 @@ function serializeFrame(frameId) {
   };
 }
 function serializeFrameTree() {
-  const root = Frame.root();
+  const root = Frame.getRoot();
+  if (!root) {
+    return { root: null, totalFrames: 0, timestamp: Date.now(), rootId: "" };
+  }
   const rootNode = serializeFrame(root.id);
   let totalFrames = 0;
   const countFrames = (node) => {
@@ -3251,19 +3623,22 @@ function installFrameVisualizerBridge() {
     const data = event.data;
     if (!data || typeof data !== "object") return;
     const type = data.type;
-    if (type === MSG_PING) {
+    if (type === FrameVisualBridge.MSG_PING) {
       const source = event.source;
       if (source) {
-        source.postMessage({ type: MSG_PONG }, { targetOrigin: "*" });
+        source.postMessage(
+          { type: FrameVisualBridge.MSG_PONG },
+          { targetOrigin: "*" }
+        );
       }
       return;
     }
-    if (type === MSG_REQUEST_TREE) {
+    if (type === FrameVisualBridge.MSG_REQUEST_TREE) {
       const tree = serializeFrameTree();
       const source = event.source;
       if (source) {
         source.postMessage(
-          { type: MSG_TREE, data: tree },
+          { type: FrameVisualBridge.MSG_TREE, data: tree },
           { targetOrigin: "*" }
         );
       }
@@ -3282,18 +3657,14 @@ function pushTreeUpdate() {
   const treeJson = JSON.stringify(tree);
   if (treeJson !== lastTreeJson) {
     lastTreeJson = treeJson;
-    window.parent.postMessage({ type: MSG_TREE_DELTA, data: tree }, "*");
+    window.parent.postMessage(
+      { type: FrameVisualBridge.MSG_TREE_DELTA, data: tree },
+      "*"
+    );
   }
 }
 
 // src/framework.ts
-var config = {
-  rootId: "root",
-  hashbang: "#!",
-  error: (error) => {
-    throw error;
-  }
-};
 var booted3 = false;
 var taskList = [];
 var taskIndex = 0;
@@ -3342,6 +3713,9 @@ function task(fn, args, context) {
   }
 }
 var dispatcherUpdateTag = 0;
+function isThenable(value) {
+  return !!value && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
+}
 function viewIsObserveChanged(view) {
   const loc = view.locationObserved;
   let result = false;
@@ -3355,7 +3729,7 @@ function viewIsObserveChanged(view) {
       const changedParams = lastChanged2?.params;
       if (changedParams) {
         for (const key of loc.keys) {
-          result = has(changedParams, key);
+          result = hasOwnProperty(changedParams, key);
           if (result) break;
         }
       }
@@ -3367,48 +3741,59 @@ function stateIsObserveChanged(view, stateKeys) {
   const observedKeys = view.observedStateKeys;
   if (!observedKeys) return false;
   for (const key of observedKeys) {
-    if (has(stateKeys, key)) return true;
+    if (stateKeys.has(key)) return true;
   }
   return false;
 }
 function dispatcherUpdate(frame, stateKeys) {
-  const frameInternal = frame;
-  const view = frame.view;
-  if (!view || frameInternal.dispatcherUpdateTag === dispatcherUpdateTag || view.signature <= 1) {
-    return;
-  }
-  frameInternal.dispatcherUpdateTag = dispatcherUpdateTag;
-  const isChanged = stateKeys ? stateIsObserveChanged(view, stateKeys) : viewIsObserveChanged(view);
-  let renderPromise;
-  if (isChanged) {
-    const renderResult = funcWithTry(
-      view.renderMethod ?? view.render,
-      [],
-      view,
-      noop
-    );
-    if (renderResult && typeof renderResult.then === "function") {
-      renderPromise = renderResult;
-    }
-  }
-  const children = frame.children();
-  const recurse = () => {
-    for (const childId of children) {
-      const childFrame = Frame.get(childId);
-      if (childFrame) {
-        dispatcherUpdate(childFrame, stateKeys);
+  const stack = [frame];
+  const drain = (s) => {
+    while (s.length > 0) {
+      const current = s.pop();
+      const tagged = current;
+      const view = current.view;
+      if (!view || tagged.dispatcherUpdateTag === dispatcherUpdateTag || view.signature <= 1) {
+        continue;
+      }
+      tagged.dispatcherUpdateTag = dispatcherUpdateTag;
+      const isChanged = stateKeys ? stateIsObserveChanged(view, stateKeys) : viewIsObserveChanged(view);
+      let renderPromise;
+      if (isChanged) {
+        const renderResult = funcWithTry(
+          view.renderMethod ?? view.render,
+          [],
+          view,
+          noop
+        );
+        if (isThenable(renderResult)) {
+          renderPromise = renderResult;
+        }
+      }
+      const children = current.children();
+      if (renderPromise) {
+        renderPromise.then(() => {
+          const subStack = [];
+          for (let i = children.length - 1; i >= 0; i--) {
+            const child = Frame.get(children[i]);
+            if (child) subStack.push(child);
+          }
+          drain(subStack);
+        });
+      } else {
+        for (let i = children.length - 1; i >= 0; i--) {
+          const child = Frame.get(children[i]);
+          if (child) s.push(child);
+        }
       }
     }
   };
-  if (renderPromise) {
-    renderPromise.then(recurse);
-  } else {
-    recurse();
-  }
+  drain(stack);
 }
 function dispatcherNotifyChange(e) {
-  const rootFrame2 = Frame.root();
-  const view = e.view;
+  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);
     rootFrame2.mountView(viewPath);
@@ -3425,19 +3810,6 @@ function dispatchEvent(target, eventType, eventInit) {
   });
   target.dispatchEvent(event);
 }
-function use(names, callback) {
-  if (!config.require) {
-    if (callback) callback();
-    return;
-  }
-  const nameList = typeof names === "string" ? [names] : names;
-  const result = config.require(nameList);
-  if (result && typeof result.then === "function") {
-    result.then((modules) => {
-      if (callback) callback(modules);
-    });
-  }
-}
 var WAIT_OK = 1;
 var WAIT_TIMEOUT_OR_NOT_FOUND = 0;
 function waitZoneViewsRendered(viewId, timeout) {
@@ -3460,12 +3832,27 @@ function waitZoneViewsRendered(viewId, timeout) {
     setTimeout(check, 9);
   });
 }
+function getConfigImpl(key) {
+  if (key === void 0) return config;
+  return config[key];
+}
 var Framework = {
   // ============================================================
   // Lifecycle
   // ============================================================
+  /** Read framework configuration. See `FrameworkInterface.getConfig`. */
+  getConfig: getConfigImpl,
   /**
-   * Get or set framework configuration.
+   * Merge a patch into framework configuration. See `FrameworkInterface.setConfig`.
+   */
+  setConfig(patch) {
+    if (patch && typeof patch === "object") {
+      assign(config, patch);
+    }
+    return config;
+  },
+  /**
+   * @deprecated Use `getConfig()` / `setConfig()`. Behavior unchanged.
    */
   config(cfg) {
     if (!cfg) {
@@ -3486,17 +3873,17 @@ var Framework = {
     }
     Router._setConfig(config);
     EventDelegator.setFrameGetter((id) => Frame.get(id));
-    Router.on(ROUTER_EVENTS.CHANGED, (data) => {
+    Router.on(RouterEvents.CHANGED, (data) => {
       if (data) dispatcherNotifyChange(data);
     });
-    State.on(ROUTER_EVENTS.CHANGED, (data) => {
+    State.on(RouterEvents.CHANGED, (data) => {
       if (data) dispatcherNotifyChange(data);
     });
     booted3 = true;
     markBooted();
     markRouterBooted();
     installFrameVisualizerBridge();
-    const rootFrame2 = Frame.root(config.rootId);
+    const rootFrame2 = Frame.createRoot(config.rootId);
     Router._bind();
     const defaultView = config.defaultView || "";
     if (defaultView && !rootFrame2.view) {
@@ -3551,7 +3938,7 @@ var Framework = {
   /**
    * Check if object has own property.
    */
-  has,
+  has: hasOwnProperty,
   /**
    * Get object keys.
    */
@@ -3611,6 +3998,9 @@ if (typeof window !== "undefined") {
   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/store.ts
@@ -3624,28 +4014,38 @@ var Platform = /* @__PURE__ */ ((Platform2) => {
 var isFunction = (val) => typeof val === "function";
 var isObject = (val) => val !== null && typeof val === "object";
 var isPromise = (val) => isObject(val) && isFunction(val["then"]);
-var hasOwnProperty = (obj, prop) => Object.prototype.hasOwnProperty.call(obj, prop);
-var deepClone = (obj) => {
+var hasOwnProperty2 = (obj, prop) => Object.prototype.hasOwnProperty.call(obj, prop);
+var hasStructuredClone = typeof globalThis !== "undefined" && typeof globalThis.structuredClone === "function";
+var deepCloneFallback = (obj) => {
   if (!obj || !isObject(obj)) return {};
-  const newData = Array.isArray(obj) ? [] : Object.create(Object.getPrototypeOf(obj));
+  const newData = Array.isArray(obj) ? [] : {};
   for (const key in obj) {
-    if (hasOwnProperty(obj, key)) {
+    if (hasOwnProperty2(obj, key)) {
       const value = obj[key];
-      newData[key] = isObject(value) ? deepClone(value) : value;
+      newData[key] = isObject(value) ? deepCloneFallback(value) : value;
     }
   }
   return newData;
 };
+var deepClone = (obj) => {
+  if (hasStructuredClone) {
+    try {
+      return structuredClone(obj);
+    } catch {
+      return deepCloneFallback(obj);
+    }
+  }
+  return deepCloneFallback(obj);
+};
 var cloneData = (data) => isObject(data) ? deepClone(data) : data;
 var getDataByKey = (target, key) => {
-  let data;
-  const rec = target;
-  if (key.includes(".")) {
-    key.split(".").forEach((k, index) => {
-      data = index === 0 ? rec?.[k] : data?.[k];
-    });
-  } else {
-    data = rec?.[key];
+  if (!key.includes(".")) {
+    return target[key];
+  }
+  let data = target;
+  for (const k of key.split(".")) {
+    if (!isObject(data)) return void 0;
+    data = data[k];
   }
   return data;
 };
@@ -3693,17 +4093,18 @@ var Queue = class {
 };
 var addParams2Callback = (cb, params) => {
   if (!cb || !params) return;
-  const cbObj = cb;
-  if (isObject(cb) && isObject(cbObj["params"])) {
-    Object.assign(cbObj["params"], params);
+  const tagged = cb;
+  const existing = tagged.params;
+  if (isObject(existing)) {
+    Object.assign(existing, params);
   } else {
-    cbObj["params"] = params;
+    tagged.params = params;
   }
 };
 var runTask = (cb) => {
-  const cbObj = cb;
-  const params = cbObj["params"];
-  delete cbObj["params"];
+  const tagged = cb;
+  const params = tagged.params;
+  delete tagged.params;
   try {
     cb(params);
   } catch {
@@ -3729,7 +4130,9 @@ var ArrMethods = {};
     if (res === -1 || res === false) {
       res = rawMethod.apply(
         this,
-        args.map((item) => ProxyCache.get(item) ?? item)
+        args.map(
+          (item) => isObject(item) ? ProxyCache.get(item) ?? item : item
+        )
       );
     }
     return res;
@@ -3747,6 +4150,7 @@ var inArrUpdate = false;
 });
 function needKeepArrItem(target, newVal, key) {
   if (!Array.isArray(target) || !inArrUpdate) return false;
+  if (!isObject(newVal)) return false;
   return getLinkKeys(newVal) === createLinkKeys(target, key);
 }
 var defStateConfig = {
@@ -3758,13 +4162,13 @@ var StateConfigMap = /* @__PURE__ */ new WeakMap();
 var setStateConfig = (target, config2) => {
   if (target && isObject(config2)) StateConfigMap.set(target, config2);
 };
-var getStateConfig = (target, key) => {
+function getStateConfig(target, key) {
   if (!StateConfigMap.has(target)) {
     return void 0;
   }
   const config2 = StateConfigMap.get(target);
   return key ? config2?.[key] : config2;
-};
+}
 var isState = (target) => isObject(target) && StateConfigMap.has(target);
 var createLinkKeys = (target, property) => {
   if (!hasLinkKeys(target)) return property;
@@ -3802,7 +4206,7 @@ var needKeep = (key) => {
 };
 var canSetNewVal = (params) => {
   const { property, newVal, oldVal } = params;
-  if (hasOwnProperty(params.target, property) && newVal === oldVal)
+  if (hasOwnProperty2(params.target, property) && newVal === oldVal)
     return false;
   return true;
 };
@@ -3814,16 +4218,13 @@ var getNewVal = (params) => {
   if (config2?.shallow) return newVal;
   if (needKeepVal) return newVal;
   const linkKeys = createLinkKeys(target, property);
-  const newState = createState(newVal, {
-    ...config2,
-    linkKeys
-  });
+  const newState = createState(newVal, { ...config2, linkKeys });
   if (isPromise(newVal)) handlePromise(newVal, target, property);
   return newState;
 };
 var genPayload = (params) => {
   const { target, property, newVal, oldVal } = params;
-  const config2 = getStateConfig(target) || defStateConfig;
+  const config2 = getStateConfig(target) ?? defStateConfig;
   return {
     belong: config2.belong || LARK_GLOBAL,
     target,
@@ -3833,11 +4234,12 @@ var genPayload = (params) => {
   };
 };
 var handlePromise = (child, parent, key) => {
+  const childObj = child;
   child.then((res) => {
     const parentProxy = ProxyCache.get(parent);
     if (parentProxy) {
       const oldVal = parentProxy[key];
-      if (ProxyCache.get(child) === oldVal) {
+      if (ProxyCache.get(childObj) === oldVal) {
         parentProxy[key] = res;
       }
     }
@@ -3845,7 +4247,7 @@ var handlePromise = (child, parent, key) => {
     const parentProxy = ProxyCache.get(parent);
     if (parentProxy) {
       const oldVal = parentProxy[key];
-      if (ProxyCache.get(child) === oldVal) {
+      if (ProxyCache.get(childObj) === oldVal) {
         parentProxy[key] = err;
       }
     }
@@ -3857,7 +4259,7 @@ var mark2 = (host, key) => {
   let sign;
   if (!host[_deleteKey]) {
     const markHost = host[_markObjKey] || (host[_markObjKey] = {});
-    if (!hasOwnProperty(markHost, key)) {
+    if (!hasOwnProperty2(markHost, key)) {
       markHost[key] = 0;
     }
     sign = ++markHost[key];
@@ -3894,7 +4296,7 @@ function createState(initialData, config2) {
         oldVal
       });
       if (!canSet) return true;
-      const proxyTarget = receiver || state;
+      const proxyTarget = isObject(receiver) && receiver !== null ? receiver : state;
       newVal = getNewVal({
         target: proxyTarget,
         property: strProp,
@@ -3914,7 +4316,7 @@ function createState(initialData, config2) {
     },
     deleteProperty(target, property) {
       const strProp = property;
-      if (!hasOwnProperty(target, strProp)) return true;
+      if (!hasOwnProperty2(target, strProp)) return true;
       const oldVal = Reflect.get(target, property);
       Reflect.deleteProperty(target, property);
       const payload = genPayload({
@@ -3958,11 +4360,8 @@ function shallowSet(target, key, data) {
   keep(key);
   const config2 = getStateConfig(target);
   const linkKeys = createLinkKeys(target, key);
-  target[key] = createState(data, {
-    ...config2,
-    linkKeys,
-    shallow: true
-  });
+  target[key] = createState(data, { ...config2, linkKeys, shallow: true });
+  return target[key];
 }
 var GlobalDeps = /* @__PURE__ */ new Map();
 function track(payload) {
@@ -4043,8 +4442,22 @@ var _stateKeys = /* @__PURE__ */ Symbol("state-keys");
 var _storeState = /* @__PURE__ */ Symbol("store-state");
 var _storeDefScheduler = /* @__PURE__ */ Symbol("store-def-scheduler");
 var _storeProxy = /* @__PURE__ */ Symbol("fn:store-proxy");
+var _computedKeys = /* @__PURE__ */ Symbol("store-computed-keys");
+var COMPUTED_BRAND = /* @__PURE__ */ Symbol("store-computed-brand");
+function computed(deps, fn) {
+  const marker = {
+    [COMPUTED_BRAND]: true,
+    deps,
+    fn
+  };
+  return marker;
+}
+function isComputedMarker(val) {
+  return isObject(val) && val[COMPUTED_BRAND] === true;
+}
 var BaseStore = class {
   [_storeStatus] = 0 /* BEFORE_CREATE */;
+  [_computedKeys] = /* @__PURE__ */ new Set();
   [_storeDefScheduler] = getDefScheduler;
   [_storeBoot]() {
     this[_storeStatus] = 2 /* ACTIVE */;
@@ -4067,10 +4480,16 @@ var BaseStore = class {
     if (isObject(body)) {
       const state = {};
       const handlers = {};
+      const computedDefs = {};
+      const computedKeys = this[_computedKeys];
       Reflect.ownKeys(body).forEach((key) => {
         const strKey = key;
         const val = body[strKey];
-        if (isFunction(val)) {
+        if (isComputedMarker(val)) {
+          computedDefs[strKey] = val;
+          state[strKey] = void 0;
+          computedKeys.add(strKey);
+        } else if (isFunction(val)) {
           if (!excludeFns.includes(strKey)) handlers[strKey] = val;
         } else {
           state[strKey] = val;
@@ -4080,6 +4499,22 @@ var BaseStore = class {
       this[_originState] = cloneData(state);
       this[_stateKeys] = Object.keys(state);
       this[_storeState] = createState(state, { belong: this[_storeName] });
+      if (Object.keys(computedDefs).length > 0) {
+        const belong = this[_storeName];
+        const storeState = this[_storeState];
+        for (const key of Object.keys(computedDefs)) {
+          const def = computedDefs[key];
+          const recompute = () => {
+            storeState[key] = def.fn();
+          };
+          recompute();
+          const trackList = def.deps.map((depKey) => ({
+            key: depKey,
+            cb: recompute
+          }));
+          if (trackList.length > 0) track({ belong, trackList });
+        }
+      }
     }
   }
   constructor(name, config2) {
@@ -4101,18 +4536,21 @@ var BaseStore = class {
   }
   [_storeProxy](toOut = false) {
     const self = this;
-    return new Proxy(self, {
+    const proxy = new Proxy(self, {
       get(target, property) {
-        if (self[_stateKeys].includes(property)) {
-          const val = self[_storeState][property];
+        const strProp = property;
+        if (self[_stateKeys].includes(strProp)) {
+          const val = self[_storeState][strProp];
           return toOut ? cloneData(val) : val;
         }
         return Reflect.get(target, property);
       },
       set(_target, property, val) {
         if (toOut) return true;
-        if (self[_stateKeys].includes(property)) {
-          self[_storeState][property] = val;
+        const strProp = property;
+        if (self[_computedKeys].has(strProp)) return true;
+        if (self[_stateKeys].includes(strProp)) {
+          self[_storeState][strProp] = val;
         }
         return true;
       },
@@ -4120,11 +4558,14 @@ var BaseStore = class {
         return Reflect.has(target, property) || self[_stateKeys].includes(property);
       }
     });
+    return proxy;
   }
 };
 var LarkUtils = {
   isLarkView(instance) {
-    return isObject(instance) && !!instance.updater;
+    if (!isObject(instance)) return false;
+    const updater = instance["updater"];
+    return isObject(updater) && isFunction(updater["set"]) && isFunction(updater["digest"]);
   },
   getRender(view) {
     return view.updater.digest.bind(view.updater);
@@ -4140,41 +4581,45 @@ var getLarkAdapter = (storeName) => ({
   Store: LarkStore,
   useStore: ((view) => {
     const store = getStore(storeName);
+    if (!(store instanceof LarkStore)) return {};
     return store[_storeBoot](view);
   })
 });
-var innerObserveFlags = /* @__PURE__ */ Symbol("store-inner-observe-flags");
-var boundViews = /* @__PURE__ */ Symbol("bound-views");
+var _innerObserveFlags = /* @__PURE__ */ Symbol("store-inner-observe-flags");
+var _boundViews = /* @__PURE__ */ Symbol("store-bound-views");
 var LarkStore = class extends BaseStore {
-  [boundViews] = /* @__PURE__ */ new Set();
-  [innerObserveFlags] = /* @__PURE__ */ new Set();
+  [_boundViews] = /* @__PURE__ */ new Set();
+  [_innerObserveFlags] = /* @__PURE__ */ new Set();
   [_storeBoot](view) {
-    if (view && LarkUtils.isLarkView(view) && !this[boundViews].has(view)) {
-      this[boundViews].add(view);
+    if (view && LarkUtils.isLarkView(view) && !this[_boundViews].has(view)) {
+      this[_boundViews].add(view);
       LarkUtils.onDestroy(view, () => {
-        this[boundViews].delete(view);
+        this[_boundViews].delete(view);
       });
     }
     return super[_storeBoot]();
   }
   [_storeDestroy]() {
-    this[boundViews].clear();
-    this[innerObserveFlags].clear();
+    this[_boundViews].clear();
+    this[_innerObserveFlags].clear();
     super[_storeDestroy]();
   }
   observe(view, keys2, defCallback) {
     if (this[_storeStatus] !== 2 /* ACTIVE */) return noop;
-    let observeKeys = keys2;
+    let observeKeys = Array.isArray(keys2) ? keys2 : [];
     const _view = view;
     const renderFn = _view ? LarkUtils.getRender(_view) : noop;
     const dateSetterFn = _view ? LarkUtils.getDataSetter(_view) : noop;
     const isInnerObserve = !view;
     const innerFlags = /* @__PURE__ */ new Set();
-    const storeInnerObserveFlags = this[innerObserveFlags];
+    const storeInnerObserveFlags = this[_innerObserveFlags];
     if (isFunction(keys2)) {
       const res = keys2();
       if (Array.isArray(res)) observeKeys = res;
     }
+    if (keys2 === void 0 && _view && observeKeys.length === 0 && Array.isArray(this[_stateKeys])) {
+      observeKeys = this[_stateKeys].slice();
+    }
     const defSetter = (immediate, key, alias, transform) => () => {
       const stateVal = getDataByKey(this, key);
       let data = { [alias || key]: stateVal };
@@ -4229,11 +4674,12 @@ var getReactAdapter = (storeName) => ({
   Store: ReactStore,
   useStore: (() => {
     const store = getStore(storeName);
+    if (!(store instanceof ReactStore)) return {};
     return store[_storeBoot]();
   })
 });
-var observeSym = /* @__PURE__ */ Symbol("observe");
-var getLastState = /* @__PURE__ */ Symbol("get-last-state");
+var _observe = /* @__PURE__ */ Symbol("store-observe");
+var _getLastState = /* @__PURE__ */ Symbol("store-get-last-state");
 var ReactStore = class extends BaseStore {
   stateChangeCount = 0;
   lastCount = 0;
@@ -4247,7 +4693,7 @@ var ReactStore = class extends BaseStore {
   }
   [_storeCreate](body) {
     super[_storeCreate](body);
-    this[observeSym](() => {
+    this[_observe](() => {
       this.stateChangeCount += 1;
     });
   }
@@ -4257,7 +4703,7 @@ var ReactStore = class extends BaseStore {
     this.lastCount = currCount;
     return changed;
   }
-  [getLastState](handlers) {
+  [_getLastState](handlers) {
     if (this.isStateChanged() || !this.lastState) {
       const state = this[_storeState];
       const immutableState = freezeData(state);
@@ -4265,7 +4711,7 @@ var ReactStore = class extends BaseStore {
     }
     return this.lastState;
   }
-  [observeSym](cb) {
+  [_observe](cb) {
     const tasks = this[_stateKeys].map((key) => ({ key, cb }));
     track({ belong: this[_storeName], trackList: tasks });
     return () => clear({ belong: this[_storeName], clearList: tasks });
@@ -4292,6 +4738,7 @@ var getNodeAdapter = (storeName) => ({
   Store: NodeStore,
   useStore: (() => {
     const store = getStore(storeName);
+    if (!(store instanceof NodeStore)) return {};
     return store[_storeBoot]();
   })
 });
@@ -4318,7 +4765,7 @@ var getPlatform = (comp) => {
   if (LarkUtils.isLarkView(comp)) return "lark" /* Lark */;
   return void 0;
 };
-var extendApis = { lazySet, shallowSet };
+var extendApis = { lazySet, shallowSet, computed };
 var StoreCache = /* @__PURE__ */ new Map();
 function defineStore(name, creator, config2) {
   if (StoreCache.has(name)) {
@@ -4329,15 +4776,20 @@ function defineStore(name, creator, config2) {
   const StoreClass = adapter.Store;
   const useStore = adapter.useStore;
   const store = new StoreClass(name, config2);
-  store[_storeCreate](
-    creator(store[_innerStore](), extendApis)
-  );
+  const innerProxy = store[_innerStore]();
+  const body = creator(innerProxy, extendApis);
+  store[_storeCreate](body);
   Object.defineProperties(useStore, {
     $storeName: { value: name, configurable: true },
     $destroyFn: { value: () => store[_storeDestroy](), configurable: true }
   });
   if (!StoreCache.has(name)) {
-    StoreCache.set(name, { store, creator, config: config2, useStore });
+    StoreCache.set(name, {
+      store,
+      creator,
+      config: config2,
+      useStore
+    });
   }
   return useStore;
 }
@@ -4359,7 +4811,7 @@ function getUseStore(name) {
   return void 0;
 }
 function cloneStore(name, useStore, config2) {
-  const oldStoreName = useStore["$storeName"];
+  const oldStoreName = useStore.$storeName ?? "";
   const cached = StoreCache.get(oldStoreName);
   const oldStoreCreator = cached?.creator;
   const oldConfig = cached?.config || {};
@@ -4380,16 +4832,12 @@ function isStoreActive(name) {
 }
 var cellCount = 0;
 function cell(data) {
-  return createState(data, {
-    belong: LARK_GLOBAL,
-    linkKeys: `${LARK_GLOBAL}_${cellCount++}`
-  });
+  const linkKeys = `${LARK_GLOBAL}_${cellCount++}`;
+  return createState(data, { belong: LARK_GLOBAL, linkKeys });
 }
 function observeCell(state, cb, immediate = true) {
   const linkKeys = getLinkKeys(state);
-  if (!linkKeys)
-    return () => {
-    };
+  if (!linkKeys) return noop;
   const keys2 = linkKeys.split(".");
   const key = keys2[keys2.length - 1];
   const list = [{ key, cb }];
@@ -4398,30 +4846,32 @@ function observeCell(state, cb, immediate = true) {
   return () => clear({ belong: LARK_GLOBAL, clearList: list });
 }
 function multi(useStore) {
-  const storeName = useStore["$storeName"];
+  const storeName = useStore.$storeName ?? "";
   const flagSym = `lark-comp-${storeName}`;
   const map = /* @__PURE__ */ new Map();
   let rootViewPath;
   const getFlag = (viewContext) => {
-    const owner = viewContext["owner"];
-    const viewPath = owner?.["path"] || "";
-    const viewId = owner?.["id"] || "";
+    const owner = viewContext.owner;
+    const viewPath = owner?.path ?? "";
+    const viewId = owner?.id ?? "";
     let flag;
     if (viewPath === rootViewPath) {
       flag = `${flagSym}-${viewId}`;
     } else {
-      flag = owner?.["viewInitParams"]?.[flagSym];
+      const initParams = owner?.viewInitParams;
+      const candidate = initParams?.[flagSym];
+      flag = typeof candidate === "string" ? candidate : void 0;
     }
-    if (owner && isFunction(owner["mountFrame"])) {
-      const rawMountFrame = owner["mountFrame"];
-      owner["mountFrame"] = (vfId, viewPath2, viewInitParams = {}) => rawMountFrame.call(
+    if (owner && isFunction(owner.mountFrame)) {
+      const rawMountFrame = owner.mountFrame;
+      owner.mountFrame = (frameId, viewPath2, viewInitParams = {}) => rawMountFrame.call(
         owner,
-        vfId,
+        frameId,
         viewPath2,
         Object.assign(viewInitParams, { [flagSym]: flag })
       );
     }
-    return flag;
+    return flag ?? "";
   };
   const useFn = ((view) => {
     if (!view)
@@ -4429,7 +4879,8 @@ function multi(useStore) {
         "[@lark.js/mvc error] multi: cannot find the view instance"
       );
     const viewCtx = view;
-    const flag = viewCtx[flagSym];
+    const tag = viewCtx[flagSym];
+    const flag = typeof tag === "string" ? tag : "";
     if (map.has(flag)) return map.get(flag);
     const newFn = cloneStore(flag, useStore);
     map.set(flag, newFn);
@@ -4438,8 +4889,7 @@ function multi(useStore) {
   const mixinObj = {
     make() {
       if (!rootViewPath) {
-        const owner = this["owner"];
-        rootViewPath = owner?.["path"] || "";
+        rootViewPath = this.owner?.path ?? "";
       }
       this[flagSym] = getFlag(this);
     }
@@ -4646,7 +5096,7 @@ function convertArtExpression(code, debug, lineNo, blockStack = []) {
     return `${debugPrefix}<%for(${forExpr}){%>`;
   }
   const tokens = code.split(/\s+/);
-  const keyword = tokens.shift();
+  const keyword = tokens.shift() ?? "";
   switch (keyword) {
     case "if": {
       blockStack.push({ ctrl: "if", line: lineNo });
@@ -4870,13 +5320,9 @@ function compileToFunction(source, debug, file) {
   }
   const viewIdRegExp = new RegExp(String.fromCharCode(31), "g");
   funcSource = funcSource.replace(viewIdRegExp, `'+$viewId+'`);
-  const atRule = hasAtRule ? `if(!$refFn){$refFn=(ref,v,k,f)=>{for(f=ref[$splitter];--f;)if(ref[k=$splitter+f]===v)return k;ref[k=$splitter+ref[$splitter]++]=v;return k;}}` : "";
-  const encode = `if(!$strSafe){let $entMap={'&':'amp','<':'lt','>':'gt','"':'#34','\\'':'#39','\`':'#96'},$entReg=/[&<>"'\`]/g,$entFn=m=>'&'+$entMap[m]+';';$strSafe=v=>''+(v==null?'':v);$encHtml=v=>$strSafe(v).replace($entReg,$entFn)}`;
-  const encodeURIMore = `if(!$encUri){let $uriMap={'!':'%21','\\'':'%27','(':'%28',')':'%29','*':'%2A'},$uriFn=m=>$uriMap[m],$uriReg=/[!')(*]/g;$encUri=v=>encodeURIComponent($strSafe(v)).replace($uriReg,$uriFn)}`;
-  const encodeQuote = `if(!$encQuote){let $qReg=/['"\\\\]/g;$encQuote=v=>$strSafe(v).replace($qReg,'\\\\$&')}`;
+  void hasAtRule;
   const refFallback = "if(!$refAlt)$refAlt=$data;";
-  const fns = `${refFallback}${encode}${encodeURIMore}${encodeQuote}${atRule};`;
-  const fullSource = `${fns}let $splitter='\\x1e',$tmp,$out=''{{VARS}};${funcSource}return $out`;
+  const fullSource = `${refFallback}let $splitter='\\x1e',$tmp,$out=''{{VARS}};${funcSource}return $out`;
   return `($data,$viewId,$refAlt,$encHtml,$strSafe,$encUri,$refFn,$encQuote)=>{${fullSource}}`;
 }
 function compileTemplate(source, options = {}) {
@@ -4888,15 +5334,12 @@ function compileTemplate(source, options = {}) {
   const funcBody = compileToFunction(finalSource, debug, file);
   const varDeclarations = globalVars.map((key) => `,${key}=$data.${key}`).join("");
   const funcWithVars = funcBody.replace("{{VARS}}", () => varDeclarations);
-  return `export default function(data, selfId, refData) {
+  return `import { encHtml as __larkEncHtml, strSafe as __larkStrSafe, encUri as __larkEncUri, encQuote as __larkEncQuote, refFn as __larkRefFn } from "@lark.js/mvc/runtime";
+export default function(data, viewId, refData) {
   let $data = data || {},
-      $viewId = selfId || '';
+      $viewId = viewId || '';
   return (${funcWithVars})($data, $viewId, refData,
-    /* $encHtml */ v => String(v == null ? '' : v).replace(/[&<>"'\`]/g, m => '&' + ({'&':'amp','<':'lt','>':'gt','"':'#34',"'":'#39','\`':'#96'})[m] + ';'),
-    /* $strSafe */ v => String(v == null ? '' : v),
-    /* $encUri */ null,
-    /* $refFn */ null,
-    /* $encQuote */ null
+    __larkEncHtml, __larkStrSafe, __larkEncUri, __larkRefFn, __larkEncQuote
   );
 }`;
 }
@@ -5021,31 +5464,37 @@ function walkAst(ast, visitors) {
     if (visitors[type]) {
       visitors[type](node);
     }
+    const bag = node;
     for (const key of Object.keys(node)) {
       if (key === "type" || key === "start" || key === "end" || key === "loc" || key === "range")
         continue;
-      if (type === "MemberExpression" && key === "property" && !node.computed)
-        continue;
-      if (type === "ObjectProperty" && key === "key" && !node.computed) {
-        continue;
+      if (type === "MemberExpression" && key === "property") {
+        const me = node;
+        if (!me.computed) continue;
       }
-      if (type === "ObjectMethod" && key === "key" && !node.computed) {
-        continue;
+      if (type === "ObjectProperty" && key === "key") {
+        const op = node;
+        if (!op.computed) continue;
       }
-      const child = node[key];
+      if (type === "ObjectMethod" && key === "key") {
+        const om = node;
+        if (!om.computed) continue;
+      }
+      const child = bag[key];
       if (Array.isArray(child)) {
         for (const item of child) {
-          if (item && typeof item === "object" && typeof item.type === "string") {
-            visit(item);
-          }
+          if (isAstNode(item)) visit(item);
         }
-      } else if (child && typeof child === "object" && typeof child.type === "string") {
+      } else if (isAstNode(child)) {
         visit(child);
       }
     }
   }
   visit(ast);
 }
+function isAstNode(v) {
+  return !!v && typeof v === "object" && typeof v.type === "string";
+}
 var BUILTIN_GLOBALS = {
   // ─── Template runtime helpers (injected by compileToFunction) ───────
   //
@@ -5199,15 +5648,17 @@ var BUILTIN_GLOBAL_SET = new Set(Object.keys(BUILTIN_GLOBALS));
 export {
   CALL_BREAK_TIME,
   Cache,
+  cross_site_default as CrossSite,
   EVENT_METHOD_REGEXP,
   EventDelegator,
   EventEmitter,
   Frame,
+  FrameVisualBridge,
   Framework,
   LARK_VIEW,
   Payload,
   Platform,
-  ROUTER_EVENTS,
+  RouterEvents as ROUTER_EVENTS,
   Router,
   SPLITTER,
   Service,
@@ -5221,13 +5672,14 @@ export {
   applyVdomOps,
   assign,
   cell,
-  classExtend,
   cloneData,
   cloneStore,
   compileTemplate,
+  computed,
   createState,
   createVdomRef,
   defineStore,
+  defineView,
   delStore,
   encodeHTML,
   encodeQ,
@@ -5235,6 +5687,7 @@ export {
   encodeURIExtra,
   ensureElementId,
   extractGlobalVars,
+  config as frameworkConfig,
   funcWithTry,
   generateId,
   getAttribute,
@@ -5242,8 +5695,9 @@ export {
   getPlatform,
   getStore,
   getUseStore,
-  has,
+  hasOwnProperty,
   installFrameVisualizerBridge,
+  invalidateViewClass,
   isPlainObject,
   isPrimitive,
   isPrimitiveOrFunc,
@@ -5262,6 +5716,7 @@ export {
   observeCell,
   parseUri,
   registerViewClass,
+  resetProjectsMap,
   safeguard,
   serializeFrameTree,
   setData,
@@ -5273,6 +5728,7 @@ export {
   toUri,
   translateData,
   unmark,
+  use,
   vdomGetCompareKey,
   vdomGetNode,
   vdomSetAttributes,