@lark.js/mvc 0.0.3 → 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) */
@@ -38,7 +38,6 @@ function isPlainObject(value) {
   if (proto === null) return true;
   return proto === Object.prototype || proto === null;
 }
-var isArray = Array.isArray;
 function isPrimitiveOrFunc(value) {
   return !value || typeof value !== "object" && typeof value !== "function";
 }
@@ -54,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);
     }
   }
@@ -70,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];
         }
       }
@@ -79,25 +78,26 @@ function assign(target, ...sources) {
   return target;
 }
 function funcWithTry(fns, args, context, configError) {
-  const fnArray = isArray(fns) ? fns : [fns];
+  const fnArray = Array.isArray(fns) ? fns : [fns];
   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);
+      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;
@@ -105,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) || isArray(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;
@@ -152,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;
       }
@@ -206,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 cProto = Object.create(baseProto);
-  assign(cProto, props);
-  Object.assign(make, statics);
-  cProto.constructor = make;
-  make["prototype"] = cProto;
-}
 
 // src/apply-style.ts
 var injectedStyleIds = /* @__PURE__ */ new Set();
@@ -253,32 +248,40 @@ function applyStyle(styleIdOrPairs, css) {
 }
 
 // src/mark.ts
-var DELETED_KEY = SPLITTER + "$a";
-var MARK_OBJECT_KEY = SPLITTER + "$b";
+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
 var proxiesPool = /* @__PURE__ */ new Map();
-var SAFEGUARD_SENTINEL = "_sf_";
+var SAFEGUARD_SENTINEL = "_safe_";
 function safeguard(data, getter, setter, isRoot) {
   if (typeof window.__lark_Debug === "undefined" || !window.__lark_Debug) {
     return data;
@@ -319,7 +322,7 @@ function safeguard(data, getter, setter, isRoot) {
         if (!prefix && getter) {
           getter(property);
         }
-        if (!isRoot && has(target, property) && (isArray(out) || isPlainObject(out))) {
+        if (!isRoot && hasOwnProperty(target, property) && (Array.isArray(out) || isPlainObject(out))) {
           return build(prefix + property + ".", out);
         }
         return out;
@@ -408,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);
     }
@@ -441,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);
       }
     }
-    this.entries = this.entries.filter((e) => e.frequency !== -1);
+    const evictSet = new Set(worst);
+    for (const e of worst) {
+      this.lookup.delete(this.prefixKey(e.originalKey));
+      if (this.onRemove) this.onRemove(e.originalKey);
+    }
+    this.entries = entries.filter((e) => !evictSet.has(e));
   }
 };
 
@@ -462,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.
    */
@@ -484,24 +519,37 @@ 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);
-      Reflect.deleteProperty(this, `on${event}`);
+      Reflect.deleteProperty(
+        this,
+        `on${event[0].toUpperCase() + event.slice(1)}`
+      );
     }
     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)
@@ -515,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}`;
-    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;
   }
@@ -555,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();
@@ -567,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;
@@ -577,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);
@@ -589,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 = {
   /**
@@ -629,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]}`
             );
@@ -650,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;
@@ -667,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;
@@ -726,6 +749,7 @@ var State = {
     emitter.fire(event, data, remove);
     return State;
   }
+  // onChanged: noop,
 };
 
 // src/router.ts
@@ -743,6 +767,7 @@ var cachedDefaultPath;
 var cachedRewrite;
 var defaultTitle;
 var frameworkConfig;
+var beforeEachGuards = [];
 function createEmptyLocation() {
   return {
     href: "",
@@ -897,7 +922,7 @@ var Router = {
         document.title = defaultTitle || document.title;
       }
       emitter2.fire(
-        ROUTER_EVENTS.CHANGED,
+        RouterEvents.CHANGED,
         lastChanged
       );
     }
@@ -930,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] = "";
           }
         }
@@ -948,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.
@@ -1019,21 +1047,48 @@ 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;
     window.addEventListener("hashchange", watchChange);
     window.addEventListener("popstate", watchChange);
     window.addEventListener("beforeunload", (domEvent) => {
-      const te = {};
-      Router.fire(ROUTER_EVENTS.PAGE_UNLOAD, te);
-      const msg = te["msg"];
+      const data = {};
+      Router.fire(RouterEvents.PAGE_UNLOAD, data);
+      const msg = data["msg"];
       if (msg) {
         domEvent.returnValue = msg;
       }
@@ -1065,26 +1120,30 @@ var frameGetter;
 function parseEventInfo(eventInfo) {
   const cached = eventInfoCache.get(eventInfo);
   if (cached) {
-    return assign({}, cached, { r: eventInfo });
+    return assign({}, cached, { value: eventInfo });
   }
   const match = eventInfo.match(EVENT_METHOD_REGEXP) || [];
   const result = {
-    v: match[1] || "",
-    n: match[2] || "",
-    i: match[3] || ""
+    id: match[1] || "",
+    name: match[2] || "",
+    params: match[3] || ""
   };
   eventInfoCache.set(eventInfo, result);
-  return assign({}, result, { r: eventInfo });
+  return assign({}, result, { value: 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.v || selectorEvents[eventType]) {
+  if (match && !match.id || hasSelectorEvents) {
     let selectorFrameId = "#";
     let backtrace = 0;
     while (begin && begin !== document.body) {
@@ -1110,10 +1169,10 @@ function findFrameInfo(current, eventType) {
           if (selectorEntry) {
             for (const selectorName of selectorEntry.selectors) {
               const entry = {
-                r: selectorName,
-                v: frameId,
-                n: selectorName,
-                i: ""
+                value: selectorName,
+                id: frameId,
+                name: selectorName,
+                params: ""
               };
               if (selectorName) {
                 if (!backtrace && elementMatchesSelector(current, selectorName)) {
@@ -1125,8 +1184,8 @@ function findFrameInfo(current, eventType) {
             }
           }
           if (view.template && !backtrace) {
-            if (match && !match.v) {
-              match.v = frameId;
+            if (match && !match.id) {
+              match.id = frameId;
             }
             break;
           }
@@ -1142,10 +1201,10 @@ function findFrameInfo(current, eventType) {
   }
   if (match) {
     eventInfos.push({
-      v: match.v,
-      r: match.r,
-      n: match.n,
-      i: match.i
+      id: match.id,
+      value: match.value,
+      name: match.name,
+      params: match.params
     });
   }
   return eventInfos;
@@ -1166,7 +1225,7 @@ function domEventProcessor(domEvent) {
     const eventInfos = findFrameInfo(current, eventType);
     if (eventInfos.length) {
       for (const info of eventInfos) {
-        const { v: frameId, n: handlerName, i: params } = info;
+        const { id: frameId, name: handlerName, params } = info;
         if (lastFrameId !== frameId) {
           if (lastFrameId && domEvent.isPropagationStopped?.()) {
             break;
@@ -1257,7 +1316,7 @@ var EventDelegator = {
 };
 
 // src/vdom.ts
-var WrapMeta = {
+var wrapMeta = {
   option: [1, "<select multiple>"],
   thead: [1, "<table>"],
   col: [2, "<table><colgroup>"],
@@ -1265,13 +1324,13 @@ var WrapMeta = {
   td: [3, "<table><tbody><tr>"],
   area: [1, "<map>"],
   param: [1, "<object>"],
-  g: [1, '<svg xmlns="' + SVG_NS + '">'],
-  m: [1, '<math xmlns="' + MATH_NS + '">'],
+  svg: [1, '<svg xmlns="' + SVG_NS + '">'],
+  math: [1, '<math xmlns="' + MATH_NS + '">'],
   _: [0, ""]
 };
-WrapMeta["optgroup"] = WrapMeta["option"];
-WrapMeta["tbody"] = WrapMeta["tfoot"] = WrapMeta["colgroup"] = WrapMeta["caption"] = WrapMeta["thead"];
-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;
@@ -1282,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) {
@@ -1299,14 +1354,14 @@ function vdomGetNode(html, refNode) {
   const ns = refNode.namespaceURI;
   let tag;
   if (ns === SVG_NS) {
-    tag = "g";
+    tag = "svg";
   } else if (ns === MATH_NS) {
-    tag = "m";
+    tag = "math";
   } else {
     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--) {
@@ -1323,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);
@@ -1336,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;
@@ -1386,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;
@@ -1400,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;
   }
@@ -1411,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]);
@@ -1451,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") || "";
@@ -1562,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;
@@ -1582,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 };
@@ -1616,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;
   }
   /**
@@ -1652,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,
@@ -1695,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;
@@ -1746,221 +1848,6 @@ if (typeof window !== "undefined") {
 if (typeof document !== "undefined") {
   VIEW_GLOBALS["document"] = document;
 }
-function viewPrepare(oView) {
-  if (oView.ctors) {
-    return oView.ctors;
-  }
-  const ctors = [];
-  oView.ctors = ctors;
-  const proto = oView.prototype;
-  const eventsObject = {};
-  const eventsList = [];
-  const selectorObject = {};
-  const mixins = proto["mixins"];
-  if (mixins && Array.isArray(mixins)) {
-    viewMergeMixins(mixins, oView, ctors);
-  }
-  for (const p in proto) {
-    if (!has(proto, p)) continue;
-    const currentFn = proto[p];
-    if (typeof currentFn !== "function") continue;
-    const matches = p.match(VIEW_EVENT_METHOD_REGEXP);
-    if (!matches) continue;
-    const isSelector = matches[1];
-    const selectorOrCallback = matches[2];
-    const events = matches[3];
-    const modifiers = matches[4];
-    const mod = {};
-    if (modifiers) {
-      for (const item of modifiers.split(",")) {
-        mod[item] = true;
-      }
-    }
-    const eventTypes = events.split(",");
-    for (const item of eventTypes) {
-      const globalNode = VIEW_GLOBALS[selectorOrCallback];
-      let mask = 1;
-      if (isSelector) {
-        if (globalNode) {
-          eventsList.push({
-            handler: currentFn,
-            element: globalNode,
-            eventName: item,
-            modifiers: mod
-          });
-          continue;
-        }
-        mask = 2;
-        let selectorEntry = selectorObject[item];
-        if (!selectorEntry) {
-          selectorEntry = selectorObject[item] = {
-            selectors: []
-          };
-        }
-        if (!selectorEntry[selectorOrCallback]) {
-          selectorEntry[selectorOrCallback] = 1;
-          selectorEntry.selectors.push(selectorOrCallback);
-        }
-      }
-      eventsObject[item] = (eventsObject[item] || 0) | mask;
-      const combinedKey = selectorOrCallback + SPLITTER + item;
-      const existingFn = proto[combinedKey];
-      if (!existingFn) {
-        proto[combinedKey] = currentFn;
-      } else {
-        const mixinFn = currentFn;
-        const existingMixin = existingFn;
-        if (existingMixin.b) {
-          if (mixinFn.b) {
-            proto[combinedKey] = processMixinsSameEvent(
-              currentFn,
-              existingFn
-            );
-          } else if (has(proto, p)) {
-            proto[combinedKey] = currentFn;
-          }
-        }
-      }
-    }
-  }
-  viewWrapMethod(proto, "render", "$b");
-  proto["$eo"] = eventsObject;
-  proto["$el"] = eventsList;
-  proto["$so"] = selectorObject;
-  proto["$f"] = proto["assign"];
-  return ctors;
-}
-function viewWrapMethod(proto, fnName, shortKey) {
-  const originalFn = proto[fnName];
-  if (typeof originalFn !== "function") return;
-  const wrapped = function(...args) {
-    if (this.signature > 0) {
-      this.signature++;
-      this.fire("rendercall");
-      destroyAllResources(this, false);
-      const instanceFn = typeof this[fnName] === "function" ? this[fnName] : originalFn;
-      const fnToCall = instanceFn === wrapped ? originalFn : instanceFn;
-      return funcWithTry(fnToCall, args, this, noop);
-    }
-    return void 0;
-  };
-  proto[fnName] = wrapped;
-  proto[shortKey] = wrapped;
-}
-function processMixinsSameEvent(additional, exist) {
-  let temp;
-  const existMixin = exist;
-  if (existMixin.a) {
-    temp = existMixin;
-  } else {
-    temp = function(...e) {
-      funcWithTry(temp.a ?? [], e, this, noop);
-    };
-    temp.a = [exist];
-    temp.b = 1;
-  }
-  const additionalMixin = additional;
-  temp.a = (temp.a ?? []).concat(additionalMixin.a ?? [additional]);
-  return temp;
-}
-function viewMergeMixins(mixins, viewClass, ctors) {
-  const proto = viewClass.prototype;
-  const temp = {};
-  for (const node of mixins) {
-    for (const p in node) {
-      if (!has(node, p)) continue;
-      const fn = node[p];
-      const exist = temp[p];
-      if (p === "make") {
-        ctors.push(fn);
-        continue;
-      }
-      if (VIEW_EVENT_METHOD_REGEXP.test(p)) {
-        if (exist) {
-          temp[p] = processMixinsSameEvent(fn, exist);
-        } else {
-          fn.b = 1;
-          temp[p] = fn;
-        }
-      } else {
-        if (!exist) {
-          temp[p] = fn;
-        }
-      }
-    }
-  }
-  for (const p in temp) {
-    if (!has(proto, p)) {
-      proto[p] = temp[p];
-    }
-  }
-}
-function viewDelegateEvents(view, destroy = false) {
-  const proto = Object.getPrototypeOf(view) ?? {};
-  const eventsObject = proto["$eo"] || view.eventObjectMap;
-  const selectorObject = proto["$so"] || view.eventSelectorMap;
-  const eventsList = proto["$el"] || view.globalEventList;
-  for (const e in eventsObject) {
-    if (has(eventsObject, e)) {
-      if (destroy) {
-        EventDelegator.unbind(e, !!selectorObject[e]);
-      } else {
-        EventDelegator.bind(e, !!selectorObject[e]);
-      }
-    }
-  }
-  for (const entry of eventsList) {
-    if (destroy) {
-      entry.element.removeEventListener(
-        entry.eventName,
-        entry.boundHandler
-      );
-    } else {
-      const handler = entry.handler;
-      const element = entry.element;
-      const modifiers = entry.modifiers;
-      entry.boundHandler = function(domEvent) {
-        const extendedEvent = domEvent;
-        extendedEvent.eventTarget = element;
-        if (modifiers) {
-          const kbEvent = domEvent;
-          if (modifiers["ctrl"] && !kbEvent.ctrlKey || modifiers["shift"] && !kbEvent.shiftKey || modifiers["alt"] && !kbEvent.altKey || modifiers["meta"] && !kbEvent.metaKey) {
-            return;
-          }
-        }
-        funcWithTry(handler, [domEvent], view, noop);
-      };
-      entry.element.addEventListener(
-        entry.eventName,
-        entry.boundHandler
-      );
-    }
-  }
-}
-function destroyAllResources(view, lastly) {
-  const cache = view.resources;
-  for (const p in cache) {
-    if (has(cache, p)) {
-      const entry = cache[p];
-      if (lastly || entry.destroyOnRender) {
-        destroyResource(cache, p, true);
-      }
-    }
-  }
-}
-function destroyResource(cache, key, callDestroy, oldEntity) {
-  const entry = cache[key];
-  if (!entry || entry.entity === oldEntity) return void 0;
-  const entity = entry.entity;
-  if (entity && typeof entity === "object") {
-    const destroyFn = entity["destroy"];
-    if (typeof destroyFn === "function" && callDestroy) {
-      funcWithTry(destroyFn, [], entity, noop);
-    }
-  }
-  Reflect.deleteProperty(cache, key);
-  return entity;
-}
 var View = class _View {
   /** View ID (same as owner frame ID) */
   id = "";
@@ -1984,18 +1871,44 @@ var View = class _View {
   observedStateKeys;
   /** Resource map */
   resources = {};
-  /** Selector event map: eventType -> handler name list */
-  eventSelectorMap = {};
-  /** Event object map: eventType -> bitmask */
-  eventObjectMap = {};
-  /** Global event list */
-  globalEventList = [];
   /** Assign method reference */
   assignMethod;
   /** Whether endUpdate pending */
   endUpdatePending;
   /** Internal event storage */
   _events = new EventEmitter();
+  // ============================================================
+  // Getters for prototype-stored event maps
+  // ============================================================
+  /** Prototype-stored event maps shape (set by View.prepare). */
+  get protoEventState() {
+    return Object.getPrototypeOf(this);
+  }
+  /**
+   * Event bitmask map: eventType -> bitmask (1=root, 2=selector).
+   * Read from prototype ($evtObjMap) set by View.prepare.
+   * Using a getter avoids ES6 class field shadowing the prototype value.
+   */
+  get eventObjectMap() {
+    return this.protoEventState.$evtObjMap ?? {};
+  }
+  /**
+   * Selector event map: eventType -> selector list.
+   * Read from prototype ($selMap) set by View.prepare.
+   */
+  get eventSelectorMap() {
+    return this.protoEventState.$selMap ?? {};
+  }
+  /**
+   * Global event list: [{handler, element, eventName, modifiers}].
+   * Read from prototype ($globalEvtList) set by View.prepare.
+   */
+  get globalEventList() {
+    return this.protoEventState.$globalEvtList ?? [];
+  }
+  // ============================================================
+  // Instance lifecycle methods
+  // ============================================================
   /**
    * Initialize view (called by Frame when mounting).
    */
@@ -2003,14 +1916,7 @@ var View = class _View {
   }
   /**
    * Render view template (called by Frame after init).
-   * Wrapped by View_WrapMethod to manage signature + resources.
-   *
-   * Default implementation calls updater.digest() which:
-   * 1. Executes the template function with current data
-   * 2. Runs VDOM diff against previous DOM
-   * 3. Applies DOM operations
-   * 4. Calls endUpdate to mount child frames
-   *
+   * Wrapped by View.wrapMethod to manage signature + resources.
    */
   render() {
     this.updater.digest();
@@ -2033,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);
     }
   }
   /**
@@ -2057,12 +1967,12 @@ 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(
           this.wrapAsync(() => {
-            runInvokes(ownerFrame);
+            _View.runInvokes(ownerFrame);
           }),
           0
         );
@@ -2096,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;
       }
     }
@@ -2138,7 +2049,7 @@ var View = class _View {
   capture(key, resource, destroyOnRender = false) {
     const cache = this.resources;
     if (resource) {
-      destroyResource(cache, key, true, resource);
+      _View.destroyResource(cache, key, true, resource);
       cache[key] = {
         entity: resource,
         destroyOnRender
@@ -2154,7 +2065,7 @@ var View = class _View {
    * If destroy=true, calls the resource's destroy() method.
    */
   release(key, destroy = true) {
-    return destroyResource(this.resources, key, destroy);
+    return _View.destroyResource(this.resources, key, destroy);
   }
   // ============================================================
   // Leave tip
@@ -2164,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) => {
@@ -2189,21 +2092,284 @@ 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);
     });
   }
   // ============================================================
-  // Static: extend and merge
+  // Static public methods
   // ============================================================
   /** Collected ctors from mixins */
   static ctors;
+  /**
+   * Prepare a View subclass by scanning its prototype for event method patterns.
+   * Pattern: `$?name<eventType1,eventType2>(&modifiers)`
+   *
+   * Only runs once per View subclass (guarded by ctors marker).
+   * Called from Frame.mountView before creating the view instance.
+   */
+  static prepare(oView) {
+    if (oView.ctors) {
+      return oView.ctors;
+    }
+    const ctors = [];
+    oView.ctors = ctors;
+    const proto = oView.prototype;
+    const eventsObject = {};
+    const eventsList = [];
+    const selectorObject = {};
+    const mixins = proto["mixins"];
+    if (mixins && Array.isArray(mixins)) {
+      _View.mergeMixins(mixins, oView, ctors);
+    }
+    for (const p in proto) {
+      if (!hasOwnProperty(proto, p)) continue;
+      const currentFn = proto[p];
+      if (typeof currentFn !== "function") continue;
+      const matches = p.match(VIEW_EVENT_METHOD_REGEXP);
+      if (!matches) continue;
+      const isSelector = matches[1];
+      const selectorOrCallback = matches[2];
+      const events = matches[3];
+      const modifiers = matches[4];
+      const mod = {};
+      if (modifiers) {
+        for (const item of modifiers.split(",")) {
+          mod[item] = true;
+        }
+      }
+      const eventTypes = events.split(",");
+      for (const item of eventTypes) {
+        const globalNode = VIEW_GLOBALS[selectorOrCallback];
+        let mask = 1;
+        if (isSelector) {
+          if (globalNode) {
+            eventsList.push({
+              handler: currentFn,
+              element: globalNode,
+              eventName: item,
+              modifiers: mod
+            });
+            continue;
+          }
+          mask = 2;
+          let selectorEntry = selectorObject[item];
+          if (!selectorEntry) {
+            selectorEntry = selectorObject[item] = {
+              selectors: []
+            };
+          }
+          if (!selectorEntry[selectorOrCallback]) {
+            selectorEntry[selectorOrCallback] = 1;
+            selectorEntry.selectors.push(selectorOrCallback);
+          }
+        }
+        eventsObject[item] = (eventsObject[item] || 0) | mask;
+        const combinedKey = selectorOrCallback + SPLITTER + item;
+        const existingFn = proto[combinedKey];
+        if (!existingFn) {
+          proto[combinedKey] = currentFn;
+        } else if (typeof existingFn === "function") {
+          const mixinFn = currentFn;
+          const existingMixin = existingFn;
+          if (existingMixin.marker) {
+            if (mixinFn.marker) {
+              proto[combinedKey] = _View.processMixinsSameEvent(
+                mixinFn,
+                existingMixin
+              );
+            } else if (hasOwnProperty(proto, p)) {
+              proto[combinedKey] = currentFn;
+            }
+          }
+        }
+      }
+    }
+    _View.wrapMethod(proto, "render", "$renderWrap");
+    proto["$evtObjMap"] = eventsObject;
+    proto["$globalEvtList"] = eventsList;
+    proto["$selMap"] = selectorObject;
+    proto["$assignFn"] = proto["assign"];
+    return ctors;
+  }
+  /**
+   * Bind or unbind event delegation for a view instance.
+   * Called from Frame during mount/unmount.
+   */
+  static delegateEvents(view, destroy = false) {
+    const eventsObject = view.eventObjectMap;
+    const selectorObject = view.eventSelectorMap;
+    const eventsList = view.globalEventList;
+    for (const e in eventsObject) {
+      if (hasOwnProperty(eventsObject, e)) {
+        if (destroy) {
+          EventDelegator.unbind(e, !!selectorObject[e]);
+        } else {
+          EventDelegator.bind(e, !!selectorObject[e]);
+        }
+      }
+    }
+    for (const entry of eventsList) {
+      if (destroy) {
+        entry.element.removeEventListener(
+          entry.eventName,
+          entry.boundHandler
+        );
+      } else {
+        const handler = entry.handler;
+        const element = entry.element;
+        const modifiers = entry.modifiers;
+        entry.boundHandler = function(domEvent) {
+          const extendedEvent = domEvent;
+          extendedEvent.eventTarget = element;
+          if (modifiers) {
+            const kbEvent = domEvent;
+            if (modifiers["ctrl"] && !kbEvent.ctrlKey || modifiers["shift"] && !kbEvent.shiftKey || modifiers["alt"] && !kbEvent.altKey || modifiers["meta"] && !kbEvent.metaKey) {
+              return;
+            }
+          }
+          funcWithTry(handler, [domEvent], view, noop);
+        };
+        entry.element.addEventListener(
+          entry.eventName,
+          entry.boundHandler
+        );
+      }
+    }
+  }
+  /**
+   * Destroy all resources managed by a view.
+   * If lastly=true, destroy ALL resources; otherwise only destroyOnRender ones.
+   */
+  static destroyAllResources(view, lastly) {
+    const cache = view.resources;
+    for (const p in cache) {
+      if (hasOwnProperty(cache, p)) {
+        const entry = cache[p];
+        if (lastly || entry.destroyOnRender) {
+          _View.destroyResource(cache, p, true);
+        }
+      }
+    }
+  }
+  /**
+   * Process deferred invoke calls on a frame.
+   */
+  static runInvokes(frame) {
+    const list = frame.invokeList;
+    if (!list) return;
+    while (list.length) {
+      const entry = list.shift();
+      if (entry && !entry.removed) {
+        frame.invoke(entry.name, entry.args);
+      }
+    }
+  }
+  // ============================================================
+  // Static private methods
+  // ============================================================
+  /**
+   * Wrap a method on the prototype to add signature checking and resource cleanup.
+   */
+  static wrapMethod(proto, fnName, shortKey) {
+    const originalFn = proto[fnName];
+    if (typeof originalFn !== "function") return;
+    const originalAsFn = originalFn;
+    const wrapped = function(...args) {
+      if (this.signature > 0) {
+        this.signature++;
+        this.fire("render");
+        _View.destroyAllResources(this, false);
+        const lookup = this;
+        const candidate = lookup[fnName];
+        const instanceFn = typeof candidate === "function" ? candidate : originalAsFn;
+        const fnToCall = instanceFn === wrapped ? originalAsFn : instanceFn;
+        return funcWithTry(fnToCall, args, this, noop);
+      }
+      return void 0;
+    };
+    proto[fnName] = wrapped;
+    proto[shortKey] = wrapped;
+  }
+  /**
+   * When two mixins define the same event method, merge them into
+   * a single function that calls both in sequence.
+   */
+  static processMixinsSameEvent(additional, exist) {
+    let temp;
+    if (exist.handlerList) {
+      temp = exist;
+    } else {
+      const merged = function(...e) {
+        funcWithTry(merged.handlerList ?? [], e, this, noop);
+      };
+      merged.handlerList = [exist];
+      merged.marker = 1;
+      temp = merged;
+    }
+    temp.handlerList = (temp.handlerList ?? []).concat(
+      additional.handlerList ?? [additional]
+    );
+    return temp;
+  }
+  /**
+   * Merge an array of mixin objects into the view prototype.
+   */
+  static mergeMixins(mixins, viewClass, ctors) {
+    const proto = viewClass.prototype;
+    const temp = {};
+    for (const node of mixins) {
+      for (const p in node) {
+        if (!hasOwnProperty(node, p)) continue;
+        const fn = node[p];
+        if (typeof fn !== "function") continue;
+        const mixinFn = fn;
+        const exist = temp[p];
+        if (p === "make") {
+          ctors.push(mixinFn);
+          continue;
+        }
+        if (VIEW_EVENT_METHOD_REGEXP.test(p)) {
+          if (exist) {
+            temp[p] = _View.processMixinsSameEvent(mixinFn, exist);
+          } else {
+            mixinFn.marker = 1;
+            temp[p] = mixinFn;
+          }
+        } else if (!exist) {
+          temp[p] = mixinFn;
+        }
+      }
+    }
+    for (const p in temp) {
+      if (!hasOwnProperty(proto, p)) {
+        proto[p] = temp[p];
+      }
+    }
+  }
+  /**
+   * Destroy a single resource entry.
+   */
+  static destroyResource(cache, key, callDestroy, oldEntity) {
+    const entry = cache[key];
+    if (!entry || entry.entity === oldEntity) return void 0;
+    const entity = entry.entity;
+    if (entity && typeof entity === "object") {
+      const destroyFn = entity["destroy"];
+      if (typeof destroyFn === "function" && callDestroy) {
+        funcWithTry(destroyFn, [], entity, noop);
+      }
+    }
+    Reflect.deleteProperty(cache, key);
+    return entity;
+  }
+  // ============================================================
+  // Static: extend and merge
+  // ============================================================
   /**
    * Extend View to create a new View subclass.
    *
@@ -2213,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") {
-            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;
@@ -2245,56 +2412,110 @@ 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];
         }
       }
     }
-    ChildView.merge = viewMerge;
-    ChildView.extend = _View.extend;
     return ChildView;
   }
   /**
    * Merge mixins into View prototype.
    */
   static merge(...mixins) {
-    const self = this;
-    const existingCtors = self.ctors || [];
-    viewMergeMixins(mixins, self, existingCtors);
-    return self;
+    const existingCtors = this.ctors || [];
+    _View.mergeMixins(mixins, this, existingCtors);
+    return this;
   }
 };
-function viewMerge(...mixins) {
-  const self = this;
-  const existingCtors = self.ctors || [];
-  viewMergeMixins(mixins, self, existingCtors);
-  return self;
+function defineView(props, statics) {
+  return View.extend(props, statics);
 }
-function runInvokes(frame) {
-  const list = frame.invokeList;
-  if (!list) return;
-  while (list.length) {
-    const entry = list.shift();
-    if (entry && !entry.removed) {
-      frame.invoke(entry.name, entry.args);
-    }
+
+// 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;
@@ -2309,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) */
@@ -2381,31 +2602,42 @@ 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.
    */
   doMountView(ViewClass, params, node, sign) {
     if (sign !== this.signature) return;
-    const mixinCtors = viewPrepare(ViewClass);
-    const ViewConstructor = ViewClass;
-    const view = new ViewConstructor(
-      this.id,
-      this,
-      params,
-      node,
-      mixinCtors
-    );
+    const mixinCtors = View.prepare(ViewClass);
+    const Ctor = ViewClass;
+    const view = new Ctor(this.id, this, params, node, mixinCtors);
     this.viewInstance = view;
     view.signature = 1;
-    viewDelegateEvents(view);
+    View.delegateEvents(view);
     const initResult = funcWithTry(
       view.init,
       [params, { node, deep: !view.template }],
@@ -2416,13 +2648,10 @@ var Frame = class _Frame extends EventEmitter {
     Promise.resolve(initResult).then(() => {
       if (nextSign !== this.signature) return;
       if (view.template) {
-        const renderFn = view.$b;
-        if (renderFn) {
-          renderFn.call(view);
-        }
+        view.render();
       } else {
         this.hasAltered = 0;
-        if (!view.$e) {
+        if (!view.endUpdatePendingFlag) {
           view.endUpdate();
         }
       }
@@ -2486,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);
@@ -2505,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);
@@ -2524,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);
         }
@@ -2538,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);
       }
     }
@@ -2565,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;
@@ -2595,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
   // ============================================================
@@ -2606,10 +2851,27 @@ 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 || "lark-root";
+      rootId = rootId || "root";
       let rootElement = document.getElementById(rootId);
       if (!rootElement) {
         rootElement = document.body;
@@ -2619,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);
@@ -2634,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;
@@ -2663,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);
       }
@@ -2679,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);
       }
     }
@@ -2694,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);
 }
@@ -2702,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);
@@ -2712,37 +2988,153 @@ 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 Bag = class {
-  /** Bag data */
+var Payload = class {
+  /** Payload data */
   data;
   /** Internal cache info */
   cacheInfo;
   constructor(data = {}) {
     this.data = data;
   }
-  /** Get a value from bag data */
+  /** Get a value from payload data */
   get(key) {
     return this.data[key];
   }
-  /** Set a value in bag data */
+  /** Set a value in payload data */
   set(keyOrData, value) {
     if (typeof keyOrData === "string") {
       this.data[keyOrData] = value;
@@ -2754,297 +3146,398 @@ var Bag = class {
 };
 var FETCH_FLAGS_ALL = 1;
 var FETCH_FLAGS_ONE = 2;
-function createServiceType(syncFn, cacheMax = 20, cacheBuffer = 5) {
-  const metas = {};
-  const bagCache = new Cache({
-    maxSize: cacheMax,
-    bufferSize: cacheBuffer
-  });
-  const pendingCacheKeys = {};
-  const staticEmitter2 = new EventEmitter();
-  const serviceType = {
-    add(attrs) {
-      if (!isArray(attrs)) {
-        attrs = [attrs];
-      }
-      for (const bag of attrs) {
-        if (bag) {
-          const name = bag.name;
-          const cache = bag.cache;
-          bag.cache = cache ? cache | 0 : 0;
-          metas[name] = bag;
-        }
-      }
-    },
-    meta(attrs) {
-      const name = typeof attrs === "string" ? attrs : attrs["name"];
-      return metas[name] || attrs;
-    },
-    create(attrs) {
-      const meta = serviceType.meta(attrs);
-      const cache = attrs["cache"] | 0 || meta.cache || 0;
-      const entity = new Bag();
-      entity.set(meta);
-      entity.cacheInfo = {
-        name: meta.name,
-        after: meta.after,
-        cleans: meta.cleans,
-        key: cache ? defaultCacheKey(meta, attrs) : "",
-        time: 0
-      };
-      if (typeof attrs === "object" && attrs !== null) {
-        entity.set(attrs);
-      }
-      const before = meta.before;
-      if (before) {
-        funcWithTry(before, [entity], entity, noop);
-      }
-      staticEmitter2.fire("begin", { bag: entity });
-      return entity;
-    },
-    get(attrs, createNew) {
-      let entity;
-      let needsUpdate = false;
-      if (!createNew) {
-        entity = serviceType.cached(attrs);
-      }
-      if (!entity) {
-        entity = serviceType.create(attrs);
-        needsUpdate = true;
-      }
-      return { entity, needsUpdate };
-    },
-    cached(attrs) {
-      const meta = serviceType.meta(attrs);
-      const cache = attrs["cache"] | 0 || meta.cache || 0;
-      let cacheKey = "";
-      if (cache) {
-        cacheKey = defaultCacheKey(meta, attrs);
-      }
-      if (cacheKey) {
-        const info = pendingCacheKeys[cacheKey];
-        if (info) {
-          return info.e;
-        }
-        const cached = bagCache.get(cacheKey);
-        if (cached && cached.cacheInfo) {
-          if (now() - cached.cacheInfo.time > cache) {
-            bagCache.del(cacheKey);
-            return void 0;
+var Service = class {
+  /** Service instance ID */
+  id = "";
+  /** Whether service is busy (1 = busy) */
+  busy = 0;
+  /** Whether service is destroyed (1 = destroyed) */
+  destroyed = 0;
+  /** Task queue for sequential operations */
+  taskQueue = [];
+  /** Previous dequeue arguments */
+  prevArgs = [];
+  /** Instance event emitter */
+  _emitter = new EventEmitter();
+  constructor() {
+    this.id = generateId("service");
+  }
+  // ============================================================
+  // Instance accessors for type-level data
+  // ============================================================
+  /** Instance event emitter (public accessor) */
+  get emitter() {
+    return this._emitter;
+  }
+  /**
+   * Get internals object for serviceSend compatibility.
+   * References per-type static state from the current class.
+   */
+  get internals() {
+    const ctor = this.constructor;
+    return {
+      metaList: ctor._metaList,
+      payloadCache: ctor._payloadCache,
+      pendingCacheKeys: ctor._pendingCacheKeys,
+      syncFn: ctor._syncFn,
+      staticEmitter: ctor._staticEmitter
+    };
+  }
+  /**
+   * Get type reference (the constructor) for serviceSend compatibility.
+   * Static methods like get/create are accessible via the constructor.
+   */
+  get type() {
+    return this.constructor;
+  }
+  // ============================================================
+  // Instance methods
+  // ============================================================
+  /**
+   * Fetch all endpoints, callback when all complete.
+   * Uses cache when available.
+   */
+  all(attrs, done) {
+    serviceSend(this, attrs, done, FETCH_FLAGS_ALL, false);
+    return this;
+  }
+  /**
+   * Fetch all endpoints, callback on each completion.
+   */
+  one(attrs, done) {
+    serviceSend(this, attrs, done, FETCH_FLAGS_ONE, false);
+    return this;
+  }
+  /**
+   * Fetch all endpoints, skip cache (always request).
+   */
+  save(attrs, done) {
+    serviceSend(this, attrs, done, FETCH_FLAGS_ALL, true);
+    return this;
+  }
+  /**
+   * Enqueue a task for sequential execution.
+   */
+  enqueue(callback) {
+    if (!this.destroyed) {
+      this.taskQueue.push(callback);
+      this.dequeue(...this.prevArgs);
+    }
+    return this;
+  }
+  /**
+   * Dequeue and execute the next task in queue.
+   */
+  dequeue(...args) {
+    if (!this.busy && !this.destroyed) {
+      this.busy = 1;
+      setTimeout(() => {
+        this.busy = 0;
+        if (!this.destroyed) {
+          const task2 = this.taskQueue.shift();
+          if (task2) {
+            this.prevArgs = args;
+            funcWithTry(task2, args, this, noop);
           }
-          return cached;
         }
+      }, 0);
+    }
+  }
+  /**
+   * Destroy the service instance.
+   * After destruction, no new requests can be sent.
+   */
+  destroy() {
+    this.destroyed = 1;
+    this.taskQueue = [];
+  }
+  // Instance event methods (delegate to instance emitter)
+  on(event, handler) {
+    this._emitter.on(event, handler);
+    return this;
+  }
+  off(event, handler) {
+    this._emitter.off(event, handler);
+    return this;
+  }
+  fire(event, data) {
+    this._emitter.fire(event, data);
+    return this;
+  }
+  // ============================================================
+  // Per-type static state
+  // ============================================================
+  /** Per-type metadata registry */
+  static _metaList = {};
+  /** Per-type payload cache (LFU with frequency eviction) */
+  static _payloadCache = new Cache({
+    maxSize: 20,
+    bufferSize: 5
+  });
+  /** Per-type pending cache keys for deduplication */
+  static _pendingCacheKeys = {};
+  /** Per-type sync function */
+  static _syncFn = noop;
+  /** Per-type static event emitter */
+  static _staticEmitter = new EventEmitter();
+  /** Per-type cache max size */
+  static _cacheMax = 20;
+  /** Per-type cache buffer size */
+  static _cacheBuffer = 5;
+  // ============================================================
+  // Static methods (operate on per-type state via `this`)
+  // ============================================================
+  /**
+   * Register API endpoint metadata.
+   */
+  static add(attrs) {
+    if (!Array.isArray(attrs)) {
+      attrs = [attrs];
+    }
+    for (const payload of attrs) {
+      if (payload) {
+        const name = payload.name;
+        const cache = payload.cache;
+        payload.cache = cache ? cache | 0 : 0;
+        this._metaList[name] = payload;
       }
-      return void 0;
-    },
-    clear(names) {
-      const nameList = (typeof names === "string" ? names : names.join(",")).split(",");
-      const nameSet = {};
-      for (const n of nameList) {
-        nameSet[n] = 1;
-      }
-      const keysToDelete = [];
-      bagCache.forEach((bag) => {
-        if (bag?.cacheInfo && nameSet[bag.cacheInfo.name]) {
-          if (bag.cacheInfo.key) {
-            keysToDelete.push(bag.cacheInfo.key);
-          }
+    }
+  }
+  /**
+   * Get metadata for an API endpoint.
+   */
+  static meta(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 = toCacheValue(attrs["cache"]) || meta.cache || 0;
+    const entity = new Payload();
+    entity.set(meta);
+    entity.cacheInfo = {
+      name: meta.name,
+      after: typeof meta.after === "function" ? meta.after : void 0,
+      cleans: typeof meta.cleanKeys === "string" ? meta.cleanKeys : void 0,
+      key: cache ? defaultCacheKey(meta, attrs) : "",
+      time: 0
+    };
+    if (attrs !== null) {
+      entity.set(attrs);
+    }
+    const before = meta.before;
+    if (typeof before === "function") {
+      funcWithTry(before, [entity], entity, noop);
+    }
+    this._staticEmitter.fire("begin", { payload: entity });
+    return entity;
+  }
+  /**
+   * Get or create a Payload for an API request.
+   */
+  static get(attrs, createNew) {
+    let entity;
+    let needsUpdate = false;
+    if (!createNew) {
+      entity = this.cached(attrs);
+    }
+    if (!entity) {
+      entity = this.create(attrs);
+      needsUpdate = true;
+    }
+    return { entity, needsUpdate };
+  }
+  /**
+   * Get cached Payload if available and not expired.
+   */
+  static cached(attrs) {
+    const meta = this.meta(attrs);
+    const cache = toCacheValue(attrs["cache"]) || meta.cache || 0;
+    let cacheKey = "";
+    if (cache) {
+      cacheKey = defaultCacheKey(meta, attrs);
+    }
+    if (cacheKey) {
+      const info = this._pendingCacheKeys[cacheKey];
+      if (info) {
+        const entity = info.entity;
+        return entity instanceof Payload ? entity : void 0;
+      }
+      const cached = this._payloadCache.get(cacheKey);
+      if (cached && cached.cacheInfo) {
+        if (now() - cached.cacheInfo.time > cache) {
+          this._payloadCache.del(cacheKey);
+          return void 0;
         }
-      });
-      for (const key of keysToDelete) {
-        bagCache.del(key);
+        return cached;
       }
-    },
-    on(event, handler) {
-      staticEmitter2.on(event, handler);
-    },
-    off(event, handler) {
-      staticEmitter2.off(event, handler);
-    },
-    fire(event, data) {
-      staticEmitter2.fire(event, data);
-    },
-    extend(newSyncFn, newCacheMax, newCacheBuffer) {
-      return createServiceType(
-        newSyncFn,
-        newCacheMax || cacheMax,
-        newCacheBuffer || cacheBuffer
-      );
     }
-  };
-  const internals = {
-    metas,
-    bagCache,
-    pendingCacheKeys,
-    syncFn,
-    staticEmitter: staticEmitter2
-  };
-  function ServiceInstance() {
-    this.id = generateId("s");
-    this["$e"] = 0;
-    this["$d"] = 0;
-    this["$g"] = [];
-    this["$h"] = [];
-    this._emitter = new EventEmitter();
-    this._internals = internals;
-    this._type = serviceType;
-  }
-  ServiceInstance.prototype = {
-    all(attrs, done) {
-      serviceSend(this, attrs, done, FETCH_FLAGS_ALL, false);
-      return this;
-    },
-    one(attrs, done) {
-      serviceSend(this, attrs, done, FETCH_FLAGS_ONE, false);
-      return this;
-    },
-    save(attrs, done) {
-      serviceSend(this, attrs, done, FETCH_FLAGS_ALL, true);
-      return this;
-    },
-    enqueue(callback) {
-      if (!this["$d"]) {
-        this["$g"].push(callback);
-        this.dequeue(...this["$h"]);
-      }
-      return this;
-    },
-    dequeue(...args) {
-      if (!this["$e"] && !this["$d"]) {
-        this["$e"] = 1;
-        setTimeout(() => {
-          this["$e"] = 0;
-          if (!this["$d"]) {
-            const task2 = this["$g"].shift();
-            if (task2) {
-              this["$h"] = args;
-              funcWithTry(task2, args, this, noop);
-            }
-          }
-        }, 0);
+    return void 0;
+  }
+  /**
+   * Clear cached payloads by endpoint name.
+   */
+  static clear(names) {
+    const nameSet = new Set(
+      (typeof names === "string" ? names : names.join(",")).split(",")
+    );
+    const keysToDelete = [];
+    this._payloadCache.forEach((payload) => {
+      const info = payload?.cacheInfo;
+      if (info && info.key && nameSet.has(info.name)) {
+        keysToDelete.push(info.key);
       }
-    },
-    destroy() {
-      this["$d"] = 1;
-      this["$g"] = [];
-    },
-    on(event, handler) {
-      this._emitter.on(event, handler);
-      return this;
-    },
-    off(event, handler) {
-      this._emitter.off(event, handler);
-      return this;
-    },
-    fire(event, data) {
-      this._emitter.fire(event, data);
-      return this;
+    });
+    for (const key of keysToDelete) {
+      this._payloadCache.del(key);
     }
-  };
-  const staticsMap = {
-    add: serviceType.add,
-    meta: serviceType.meta,
-    create: serviceType.create,
-    get: serviceType.get,
-    cached: serviceType.cached,
-    clear: serviceType.clear,
-    on: serviceType.on,
-    off: serviceType.off,
-    fire: serviceType.fire,
-    extend: serviceType.extend,
-    _internals: internals
-  };
-  const constructor = Object.assign(
-    ServiceInstance,
-    staticsMap
-  );
-  return constructor;
+  }
+  // Static event methods (operate on per-type emitter)
+  static on(event, handler) {
+    this._staticEmitter.on(event, handler);
+  }
+  static off(event, handler) {
+    this._staticEmitter.off(event, handler);
+  }
+  static fire(event, data) {
+    this._staticEmitter.fire(event, data);
+  }
+  /**
+   * Create a new Service subclass with a custom sync function.
+   *
+   * Each subclass gets its OWN copies of every per-type static field
+   * (`_metaList`, `_payloadCache`, `_pendingCacheKeys`, `_syncFn`,
+   * `_staticEmitter`, `_cacheMax`, `_cacheBuffer`) via `static override`.
+   * This is intentional: it ensures that endpoint metadata, cache state,
+   * in-flight dedup keys, and event subscribers are fully isolated between
+   * different Service types, even when one extends another.
+   *
+   * **Do not refactor these `static override` declarations away** — sharing
+   * them through prototype inheritance would let endpoints registered on one
+   * subclass leak into another, and the LFU cache evictions of one type
+   * would race with those of another.
+   */
+  static extend(newSyncFn, newCacheMax, newCacheBuffer) {
+    const ParentService = this;
+    class ChildService extends ParentService {
+      // Intentionally per-subclass — see Service.extend doc.
+      static _metaList = {};
+      static _payloadCache = new Cache({
+        maxSize: newCacheMax || ParentService._cacheMax,
+        bufferSize: newCacheBuffer || ParentService._cacheBuffer
+      });
+      static _pendingCacheKeys = {};
+      static _syncFn = newSyncFn;
+      static _staticEmitter = new EventEmitter();
+      static _cacheMax = newCacheMax || ParentService._cacheMax;
+      static _cacheBuffer = newCacheBuffer || ParentService._cacheBuffer;
+    }
+    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;
 }
-var Service = createServiceType(noop);
 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["$d"]) return;
-  if (service["$e"]) {
-    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["$e"] = 1;
+  service.busy = 1;
   let attrList;
   if (typeof attrs === "string") {
     attrList = [{ name: attrs }];
-  } else if (isArray(attrs)) {
+  } else if (Array.isArray(attrs)) {
     attrList = attrs;
   } else {
     attrList = [attrs];
   }
-  const internals = service._internals;
+  const internals = service.internals;
   const { syncFn, pendingCacheKeys, staticEmitter: staticEmitter2 } = internals;
   let requestCount = 0;
   const total = attrList.length;
   const doneArr = new Array(total + 1);
   const errorArgs = [];
   const remoteComplete = (idx, error) => {
-    const bag = doneArr[idx + 1];
-    let newBag = false;
+    const payload = doneArr[idx + 1];
+    let newPayload = false;
     if (error) {
       errorArgs[idx] = error;
-      staticEmitter2.fire("fail", { bag, error });
+      staticEmitter2.fire("fail", { payload, error });
     } else {
-      newBag = true;
-      staticEmitter2.fire("done", { bag });
+      newPayload = true;
+      staticEmitter2.fire("done", { payload });
     }
-    if (!service["$d"]) {
+    if (!service.destroyed) {
       const finish = requestCount === total;
       if (finish) {
-        service["$e"] = 0;
+        service.busy = 0;
         if (flag === FETCH_FLAGS_ALL) {
           doneArr[0] = errorArgs;
           funcWithTry(done, doneArr, service, noop);
         }
       }
       if (flag === FETCH_FLAGS_ONE) {
-        funcWithTry(done, [error || null, bag, finish, idx], service, noop);
+        funcWithTry(done, [error || null, payload, finish, idx], service, noop);
       }
     }
-    if (newBag) {
-      staticEmitter2.fire("end", { bag, error });
+    if (newPayload) {
+      staticEmitter2.fire("end", { payload, error });
     }
   };
   for (const attr of attrList) {
     if (!attr) continue;
     const attrObj = typeof attr === "string" ? { name: attr } : attr;
-    const bagInfo = service._type.get(attrObj, save);
-    const bagEntity = bagInfo.entity;
-    const cacheKey = bagEntity.cacheInfo?.key || "";
+    const payloadInfo = service.type.get(attrObj, save);
+    const payloadEntity = payloadInfo.entity;
+    const cacheKey = payloadEntity.cacheInfo?.key || "";
     const complete = remoteComplete.bind(null, requestCount++);
     if (cacheKey && pendingCacheKeys[cacheKey]) {
       pendingCacheKeys[cacheKey].push(complete);
-    } else if (bagInfo.needsUpdate) {
+    } else if (payloadInfo.needsUpdate) {
       if (cacheKey) {
         const cacheList = [complete];
-        cacheList.e = bagEntity;
+        cacheList.entity = payloadEntity;
         pendingCacheKeys[cacheKey] = cacheList;
         const cacheComplete = () => {
           const list = pendingCacheKeys[cacheKey];
-          const entity = list.e;
-          if (entity.cacheInfo) {
+          const entity = list.entity;
+          if (entity instanceof Payload && entity.cacheInfo) {
             entity.cacheInfo.time = now();
+            internals.payloadCache.set(cacheKey, entity);
           }
-          internals.bagCache.set(cacheKey, entity);
           Reflect.deleteProperty(pendingCacheKeys, cacheKey);
           for (const cb of list) {
-            if (typeof cb === "function") {
-              cb();
-            }
+            if (typeof cb === "function") cb();
           }
         };
-        syncFn(bagEntity, cacheComplete);
+        syncFn(payloadEntity, cacheComplete);
       } else {
-        syncFn(bagEntity, complete);
+        syncFn(payloadEntity, complete);
       }
     } else {
       complete();
@@ -3052,12 +3545,14 @@ function serviceSend(service, attrs, done, flag, save) {
   }
 }
 
-// src/frame-visualizer/index.ts
-var MSG_PING = "LARK_VIS_PING";
-var MSG_PONG = "LARK_VIS_PONG";
-var MSG_REQUEST_TREE = "LARK_VIS_REQUEST_TREE";
-var MSG_TREE = "LARK_VIS_TREE";
-var MSG_TREE_DELTA = "LARK_VIS_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,
@@ -3097,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) => {
@@ -3125,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: "*" }
         );
       }
@@ -3156,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: "lark-root",
-  hashbang: "#!",
-  error: (error) => {
-    throw error;
-  }
-};
 var booted3 = false;
 var taskList = [];
 var taskIndex = 0;
@@ -3216,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;
@@ -3229,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;
         }
       }
@@ -3241,49 +3741,65 @@ 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.$b ?? 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);
   } else {
     dispatcherUpdateTag++;
-    dispatcherUpdate(rootFrame2, e["keys"]);
+    dispatcherUpdate(rootFrame2, e.keys);
   }
 }
 function dispatchEvent(target, eventType, eventInit) {
@@ -3294,23 +3810,8 @@ function dispatchEvent(target, eventType, eventInit) {
   });
   target.dispatchEvent(event);
 }
-var Base = class extends EventEmitter {
-};
-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_UNFOUND = 0;
+var WAIT_TIMEOUT_OR_NOT_FOUND = 0;
 function waitZoneViewsRendered(viewId, timeout) {
   if (timeout == null) {
     timeout = 30 * 1e3;
@@ -3321,7 +3822,7 @@ function waitZoneViewsRendered(viewId, timeout) {
     const check = () => {
       const currentTime = now();
       if (currentTime > endTime || !checkFrame) {
-        resolve(WAIT_TIMEOUT_OR_UNFOUND);
+        resolve(WAIT_TIMEOUT_OR_NOT_FOUND);
       } else if (checkFrame.childrenCount === checkFrame.readyCount) {
         resolve(WAIT_OK);
       } else {
@@ -3331,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,
+  /**
+   * Merge a patch into framework configuration. See `FrameworkInterface.setConfig`.
+   */
+  setConfig(patch) {
+    if (patch && typeof patch === "object") {
+      assign(config, patch);
+    }
+    return config;
+  },
   /**
-   * Get or set framework configuration.
+   * @deprecated Use `getConfig()` / `setConfig()`. Behavior unchanged.
    */
   config(cfg) {
     if (!cfg) {
@@ -3357,17 +3873,17 @@ var Framework = {
     }
     Router._setConfig(config);
     EventDelegator.setFrameGetter((id) => Frame.get(id));
-    Router.on(ROUTER_EVENTS.CHANGED, (data) => {
-      dispatcherNotifyChange(data);
+    Router.on(RouterEvents.CHANGED, (data) => {
+      if (data) dispatcherNotifyChange(data);
     });
-    State.on(ROUTER_EVENTS.CHANGED, (data) => {
-      dispatcherNotifyChange(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) {
@@ -3398,7 +3914,7 @@ var Framework = {
   /** Wait for zone views to be rendered */
   waitZoneViewsRendered,
   WAIT_OK,
-  WAIT_TIMEOUT_OR_UNFOUND,
+  WAIT_TIMEOUT_OR_NOT_FOUND,
   /**
    * Convert array to hash map.
    */
@@ -3422,7 +3938,7 @@ var Framework = {
   /**
    * Check if object has own property.
    */
-  has,
+  has: hasOwnProperty,
   /**
    * Get object keys.
    */
@@ -3463,7 +3979,7 @@ var Framework = {
   /**
    * Base class with EventEmitter.
    */
-  Base,
+  Base: EventEmitter,
   // ============================================================
   // Module access
   // ============================================================
@@ -3481,10 +3997,14 @@ if (typeof window !== "undefined") {
   window.__lark_State = State;
   window.__lark_Router = Router;
   window.__lark_Frame = Frame;
+  window.__lark_View = View;
+  window.__lark_invalidateViewClass = invalidateViewClass;
+  window.__lark_getViewClassRegistry = getViewClassRegistry;
+  window.__lark_registerViewClass = registerViewClass;
 }
 
 // src/store.ts
-var LARK_GLOBAL = "lark_global";
+var LARK_GLOBAL = "lark-global";
 var Platform = /* @__PURE__ */ ((Platform2) => {
   Platform2["Lark"] = "lark";
   Platform2["React"] = "react";
@@ -3494,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;
 };
@@ -3527,8 +4057,10 @@ var Queue = class {
     const flushTickTask = () => {
       while (queue.length > 0) {
         const task2 = queue.shift();
-        pendingTasks.delete(task2);
-        runTask(task2);
+        if (task2) {
+          pendingTasks.delete(task2);
+          runTask(task2);
+        }
       }
     };
     Promise.resolve().then(flushTickTask);
@@ -3561,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 {
@@ -3597,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;
@@ -3615,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 = {
@@ -3626,11 +4162,13 @@ var StateConfigMap = /* @__PURE__ */ new WeakMap();
 var setStateConfig = (target, config2) => {
   if (target && isObject(config2)) StateConfigMap.set(target, config2);
 };
-var getStateConfig = (target, key) => {
-  if (!StateConfigMap.has(target)) return void 0;
+function getStateConfig(target, key) {
+  if (!StateConfigMap.has(target)) {
+    return void 0;
+  }
   const config2 = StateConfigMap.get(target);
-  return key ? config2[key] : config2;
-};
+  return key ? config2?.[key] : config2;
+}
 var isState = (target) => isObject(target) && StateConfigMap.has(target);
 var createLinkKeys = (target, property) => {
   if (!hasLinkKeys(target)) return property;
@@ -3668,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;
 };
@@ -3680,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,
@@ -3699,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;
       }
     }
@@ -3711,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;
       }
     }
@@ -3723,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];
@@ -3760,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,
@@ -3780,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({
@@ -3824,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) {
@@ -3909,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 */;
@@ -3933,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;
@@ -3946,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) {
@@ -3967,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;
       },
@@ -3986,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);
@@ -4006,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 };
@@ -4095,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;
@@ -4113,7 +4693,7 @@ var ReactStore = class extends BaseStore {
   }
   [_storeCreate](body) {
     super[_storeCreate](body);
-    this[observeSym](() => {
+    this[_observe](() => {
       this.stateChangeCount += 1;
     });
   }
@@ -4123,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);
@@ -4131,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 });
@@ -4158,6 +4738,7 @@ var getNodeAdapter = (storeName) => ({
   Store: NodeStore,
   useStore: (() => {
     const store = getStore(storeName);
+    if (!(store instanceof NodeStore)) return {};
     return store[_storeBoot]();
   })
 });
@@ -4184,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)) {
@@ -4195,18 +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 },
-    $del: { value: () => store[_storeDestroy](), 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;
 }
@@ -4228,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 || {};
@@ -4249,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 }];
@@ -4267,49 +4846,50 @@ function observeCell(state, cb, immediate = true) {
   return () => clear({ belong: LARK_GLOBAL, clearList: list });
 }
 function multi(useStore) {
-  const storeName = useStore["$storeName"];
-  const flagSym = `lark_comp_${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}`;
+      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)
-      throw new Error("[lark-store] multi: cannot find the view instance");
+      throw new Error(
+        "[@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
-    );
+    const newFn = cloneStore(flag, useStore);
     map.set(flag, newFn);
     return useFn(view);
   });
   const mixinObj = {
     make() {
       if (!rootViewPath) {
-        const owner = this["owner"];
-        rootViewPath = owner?.["path"] || "";
+        rootViewPath = this.owner?.path ?? "";
       }
       this[flagSym] = getFlag(this);
     }
@@ -4439,7 +5019,7 @@ function convertArtSyntax(source, debug) {
   }
   if (blockStack.length > 0) {
     const unclosed = blockStack.map((b) => `"${b.ctrl}" at line ${b.line}`).join(", ");
-    throw new Error(`[@lark/mvc error] unclosed block(s): ${unclosed}`);
+    throw new Error(`[@lark.js/mvc error] unclosed block(s): ${unclosed}`);
   }
   return result.join("");
 }
@@ -4516,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 });
@@ -4533,12 +5113,12 @@ function convertArtExpression(code, debug, lineNo, blockStack = []) {
       }
       return `${debugPrefix}<%}else{%>`;
     }
-    case "each": {
-      blockStack.push({ ctrl: "each", line: lineNo });
+    case "forOf": {
+      blockStack.push({ ctrl: "forOf", line: lineNo });
       const object = tokens[0];
       if (tokens.length > 1 && tokens[1] !== "as") {
         throw new Error(
-          `[@lark/mvc error] bad each syntax: {{${code}}}. Expected "as" keyword, got "${tokens[1]}". Usage: {{each list as item [index]}}`
+          `[@lark.js/mvc error] bad forOf syntax: {{${code}}}. Expected "as" keyword, got "${tokens[1]}". Usage: {{forOf list as item [index]}}`
         );
       }
       const restTokens = tokens.slice(2);
@@ -4560,12 +5140,12 @@ function convertArtExpression(code, debug, lineNo, blockStack = []) {
       }
       return `${debugPrefix}<%for(let ${index}=0${refExpr},${refObjCount}=${refObj}.length${lastCount};${index}<${refObjCount};${index}++){${firstAndLast}${valueDecl}%>`;
     }
-    case "parse": {
-      blockStack.push({ ctrl: "parse", line: lineNo });
+    case "forIn": {
+      blockStack.push({ ctrl: "forIn", line: lineNo });
       const object = tokens[0];
       if (tokens.length > 1 && tokens[1] !== "as") {
         throw new Error(
-          `[@lark/mvc error] bad parse syntax: {{${code}}}. Expected "as" keyword, got "${tokens[1]}". Usage: {{for-in obj as val [key]}}`
+          `[@lark.js/mvc error] bad forIn syntax: {{${code}}}. Expected "as" keyword, got "${tokens[1]}". Usage: {{for-in obj as val [key]}}`
         );
       }
       const restTokens2 = tokens.slice(2);
@@ -4585,19 +5165,19 @@ function convertArtExpression(code, debug, lineNo, blockStack = []) {
     case "set":
       return `${debugPrefix}<%let ${tokens.join(" ")};%>`;
     case "/if":
-    case "/each":
-    case "/parse":
+    case "/forOf":
+    case "/forIn":
     case "/for": {
       const expectedCtrl = keyword.substring(1);
       const last = blockStack.pop();
       if (!last) {
         throw new Error(
-          `[@lark/mvc error] unexpected {{${code}}}: no matching open block`
+          `[@lark.js/mvc error] unexpected {{${code}}}: no matching open block`
         );
       }
       if (last.ctrl !== expectedCtrl) {
         throw new Error(
-          `[@lark/mvc error] unexpected {{${code}}}: expected {{/${last.ctrl}}} to close block opened at line ${last.line}`
+          `[@lark.js/mvc error] unexpected {{${code}}}: expected {{/${last.ctrl}}} to close block opened at line ${last.line}`
         );
       }
       return `${debugPrefix}<%}%>`;
@@ -4661,7 +5241,7 @@ function parseAsExpr(expr) {
 function compileToFunction(source, debug, file) {
   const matcher = /<%([@=!:])?([\s\S]*?)%>|$/g;
   let index = 0;
-  let funcSource = `$p+='`;
+  let funcSource = `$out+='`;
   let hasAtRule = false;
   const escapeSlashRegExp = /\\|'/g;
   const escapeBreakReturnRegExp = /\r|\n/g;
@@ -4687,17 +5267,17 @@ function compileToFunction(source, debug, file) {
       }
       if (operate === "@") {
         hasAtRule = true;
-        funcSource += `'+($expr='<%${operate + expr}%>',$i($$ref,${content}))+'`;
+        funcSource += `'+($dbgExpr='<%${operate + expr}%>',$refFn($refAlt,${content}))+'`;
       } else if (operate === "=" || operate === ":") {
-        funcSource += `'+($expr='<%${operate + expr}%>',$e(${content}))+'`;
+        funcSource += `'+($dbgExpr='<%${operate + expr}%>',$encHtml(${content}))+'`;
       } else if (operate === "!") {
-        if (!content.startsWith("$eu(") || !content.endsWith(")")) {
-          content = `$n(${content})`;
+        if (!content.startsWith("$encUri(") || !content.endsWith(")")) {
+          content = `$strSafe(${content})`;
         }
-        funcSource += `'+($expr='<%${operate + expr}%>',${content})+'`;
+        funcSource += `'+($dbgExpr='<%${operate + expr}%>',${content})+'`;
       } else if (content) {
         if (line > -1) {
-          funcSource += `';$line=${line};$art='${art}';`;
+          funcSource += `';$dbgLine=${line};$dbgArt='${art}';`;
           content = "";
         } else {
           funcSource += `';`;
@@ -4706,19 +5286,19 @@ function compileToFunction(source, debug, file) {
           funcSource = funcSource.substring(0, funcSource.length - 4) + ";";
         }
         if (expr) {
-          funcSource += `$expr='<%${expr}%>';`;
+          funcSource += `$dbgExpr='<%${expr}%>';`;
         }
-        funcSource += content + `;$p+='`;
+        funcSource += content + `;$out+='`;
       }
     } else {
       if (operate === "@") {
         hasAtRule = true;
-        funcSource += `'+$i($$ref,${content})+'`;
+        funcSource += `'+$refFn($refAlt,${content})+'`;
       } else if (operate === "=" || operate === ":") {
-        funcSource += `'+$e(${content})+'`;
+        funcSource += `'+$encHtml(${content})+'`;
       } else if (operate === "!") {
-        if (!content.startsWith("$eu(") || !content.endsWith(")")) {
-          content = `$n(${content})`;
+        if (!content.startsWith("$encUri(") || !content.endsWith(")")) {
+          content = `$strSafe(${content})`;
         }
         funcSource += `'+${content}+'`;
       } else if (content) {
@@ -4726,28 +5306,24 @@ function compileToFunction(source, debug, file) {
         if (funcSource.endsWith(`+'';`)) {
           funcSource = funcSource.substring(0, funcSource.length - 4) + ";";
         }
-        funcSource += `${content};$p+='`;
+        funcSource += `${content};$out+='`;
       }
     }
     return match;
   });
   funcSource += `';`;
-  funcSource = funcSource.replace(/\$p\+='';/g, "");
-  funcSource = funcSource.replace(/\$p\+=''\+/g, "$p+=");
+  funcSource = funcSource.replace(/\$out\+='';/g, "");
+  funcSource = funcSource.replace(/\$out\+=''\+/g, "$out+=");
   if (debug) {
     const filePart = file ? `\\r\\n\\tat file:${file}` : "";
-    funcSource = `let $expr,$art,$line;try{${funcSource}}catch(ex){let msg='render view error:'+(ex.message||ex);if($art)msg+='\\r\\n\\tsrc art:{{'+$art+'}}\\r\\n\\tat line:'+$line;msg+='\\r\\n\\t'+($art?'translate to:':'expr:');msg+=$expr+'${filePart}';throw msg;}`;
+    funcSource = `let $dbgExpr,$dbgArt,$dbgLine;try{${funcSource}}catch(ex){let msg='render view error:'+(ex.message||ex);if($dbgArt)msg+='\\r\\n\\tsrc art:{{'+$dbgArt+'}}\\r\\n\\tat line:'+$dbgLine;msg+='\\r\\n\\t'+($dbgArt?'translate to:':'expr:');msg+=$dbgExpr+'${filePart}';throw msg;}`;
   }
   const viewIdRegExp = new RegExp(String.fromCharCode(31), "g");
   funcSource = funcSource.replace(viewIdRegExp, `'+$viewId+'`);
-  const atRule = hasAtRule ? `if(!$i){$i=(ref,v,k,f)=>{for(f=ref[$g];--f;)if(ref[k=$g+f]===v)return k;ref[k=$g+ref[$g]++]=v;return k;}}` : "";
-  const encode = `if(!$n){let $em={'&':'amp','<':'lt','>':'gt','"':'#34','\\'':'#39','\`':'#96'},$er=/[&<>"'\`]/g,$ef=m=>'&'+$em[m]+';';$n=v=>''+(v==null?'':v);$e=v=>$n(v).replace($er,$ef)}`;
-  const encodeURIMore = `if(!$eu){let $um={'!':'%21','\\'':'%27','(':'%28',')':'%29','*':'%2A'},$uf=m=>$um[m],$uq=/[!')(*]/g;$eu=v=>encodeURIComponent($n(v)).replace($uq,$uf)}`;
-  const encodeQuote = `if(!$eq){let $qr=/['"\\\\]/g;$eq=v=>$n(v).replace($qr,'\\\\$&')}`;
-  const refFallback = "if(!$$ref)$$ref=$$;";
-  const fns = `${refFallback}${encode}${encodeURIMore}${encodeQuote}${atRule};`;
-  const fullSource = `${fns}let $g='\\x1e',$_temp,$p=''{{VARS}};${funcSource}return $p`;
-  return `($$,$viewId,$$ref,$e,$n,$eu,$i,$eq)=>{${fullSource}}`;
+  void hasAtRule;
+  const refFallback = "if(!$refAlt)$refAlt=$data;";
+  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 = {}) {
   const { debug = false, globalVars = [], file } = options;
@@ -4756,17 +5332,14 @@ function compileTemplate(source, options = {}) {
   const viewEventProcessed = processViewEvents(converted);
   const finalSource = restoreComments(viewEventProcessed, comments);
   const funcBody = compileToFunction(finalSource, debug, file);
-  const varDeclarations = globalVars.map((key) => `,${key}=$$.${key}`).join("");
+  const varDeclarations = globalVars.map((key) => `,${key}=$data.${key}`).join("");
   const funcWithVars = funcBody.replace("{{VARS}}", () => varDeclarations);
-  return `export default function(data, selfId, refData) {
-  let $$ = data || {},
-      $viewId = selfId || '';
-  return (${funcWithVars})($$, $viewId, refData,
-    /* $e */ v => String(v == null ? '' : v).replace(/[&<>"'\`]/g, m => '&' + ({'&':'amp','<':'lt','>':'gt','"':'#34',"'":'#39','\`':'#96'})[m] + ';'),
-    /* $n */ v => String(v == null ? '' : v),
-    /* $eu */ null,
-    /* $i */ null,
-    /* $eq */ null
+  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 = viewId || '';
+  return (${funcWithVars})($data, $viewId, refData,
+    __larkEncHtml, __larkStrSafe, __larkEncUri, __larkRefFn, __larkEncQuote
   );
 }`;
 }
@@ -4875,7 +5448,7 @@ function fallbackExtractVariables(source) {
   while ((m = outputRegExp.exec(source)) !== null) {
     vars.add(m[1]);
   }
-  const eachRegExp = /\{\{each\s+([a-zA-Z_$][\w$]*)\s+as/g;
+  const eachRegExp = /\{\{forOf\s+([a-zA-Z_$][\w$]*)\s+as/g;
   while ((m = eachRegExp.exec(source)) !== null) {
     vars.add(m[1]);
   }
@@ -4891,82 +5464,100 @@ 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) ───────
   //
   // These variables appear in the generated template function signature
   // or body. They must be excluded from extractGlobalVars() so that
-  // they are not mistaken for user data variables and destructured from $$.
+  // they are not mistaken for user data variables and destructured from $data.
   // SPLITTER character constant (same as \x1e), used as namespace separator
   // for refData keys, event attribute encoding, and internal data structures.
-  // Declared as: let $g='\x1e'
-  $g: 1,
-  // refData — the data object passed from Updater to the template function.
-  // User variables are destructured from $$ at the top of the function:
-  //   let {name, age} = $$;
+  // Declared as: let $splitter='\x1e'
+  $splitter: 1,
+  // Data — the data object passed from Updater to the template function.
+  // User variables are destructured from $data at the top of the function:
+  //   let {name, age} = $data;
   // This is the first parameter of the generated arrow function.
-  $$: 1,
+  $data: 1,
   // Null-safe toString: v => '' + (v == null ? '' : v)
   // Converts null/undefined to empty string, otherwise calls toString().
   // Wraps every {{!raw}} output to prevent "null" / "undefined" rendering.
-  $n: 1,
-  // HTML entity encoder: v => $n(v).replace(/[&<>"'`]/g, entityMap)
+  $strSafe: 1,
+  // HTML entity encoder: v => $strSafe(v).replace(/[&<>"'`]/g, entityMap)
   // Encodes &, <, >, ", ', ` to HTML entities (&amp; &lt; etc.)
   // Applied to all {{=escaped}} and {{:binding}} outputs.
-  $e: 1,
-  // HTML entity map — internal object used by $e:
+  $encHtml: 1,
+  // HTML entity map — internal object used by $encHtml:
   //   {'&':'amp','<':'gt','>':'gt','"':'#34','\'':'#39','`':'#96'}
-  // Not a standalone function; referenced inside $e's closure.
-  $em: 1,
-  // HTML entity RegExp — internal regexp used by $e:
+  // Not a standalone function; referenced inside $encHtml's closure.
+  $entMap: 1,
+  // HTML entity RegExp — internal regexp used by $encHtml:
   //   /[&<>"'`]/g
-  $er: 1,
-  // HTML entity replacer function — internal helper used by $e:
-  //   m => '&' + $em[m] + ';'
-  // Maps each matched character to its entity string.
-  $ef: 1,
+  $entReg: 1,
+  // HTML entity replacer function — internal helper used by $encHtml:
+  //   m => '&' + $entMap[m] + ';'
+  // Maps matched character to its entity string.
+  $entFn: 1,
   // Output buffer — the string accumulator for rendered HTML.
-  // All template output is appended via $p += '...'.
-  // Declared as: let $p = ''
-  $p: 1,
+  // All template output is appended via $out += '...'.
+  // Declared as: let $out = ''
+  $out: 1,
   // Reference lookup: (refData, value) => key
   // Finds or allocates a SPLITTER-prefixed key in refData for a given
   // object reference. Used by {{@ref}} operator for passing object
   // references to child views via v-lark attributes.
-  $i: 1,
-  // URI encoder: v => encodeURIComponent($n(v)).replace(/[!')(*]/g, extraMap)
+  $refFn: 1,
+  // URI encoder: v => encodeURIComponent($strSafe(v)).replace(/[!')(*]/g, extraMap)
   // Extends encodeURIComponent with encoding of ! ' ( ) *.
   // Applied to values in @event URL parameters and {{!uri}} contexts.
-  $eu: 1,
-  // Quote encoder: v => $n(v).replace(/['"\\]/g, '\\$&')
+  $encUri: 1,
+  // URI encode map — internal object used by $encUri:
+  //   {'!':'%21','\'':'%27','(':'%28',')':'%29','*':'%2A'}
+  $uriMap: 1,
+  // URI encode replacer — internal helper used by $encUri:
+  //   m => $uriMap[m]
+  $uriFn: 1,
+  // URI encode regexp — internal regexp used by $encUri:
+  //   /[!')(*]/g
+  $uriReg: 1,
+  // Quote encoder: v => $strSafe(v).replace(/['"\\]/g, '\\$&')
   // Escapes quotes and backslashes for safe embedding in HTML attribute
   // values (e.g. data-json='...').
-  $eq: 1,
+  $encQuote: 1,
+  // Quote encode regexp — internal regexp used by $encQuote:
+  //   /['"\\]/g
+  $qReg: 1,
   // View ID — the unique identifier of the owning View instance.
   // Injected into @event attribute values at render time so that
   // EventDelegator can dispatch events to the correct View handler.
@@ -4974,23 +5565,23 @@ var BUILTIN_GLOBALS = {
   $viewId: 1,
   // Debug: current expression text — stores the template expression being
   // evaluated, for error reporting. Only present in debug mode.
-  // e.g. $expr='<%=user.name%>'
-  $expr: 1,
+  // e.g. $dbgExpr='<%=user.name%>'
+  $dbgExpr: 1,
   // Debug: original art syntax — stores the {{}} template syntax before
   // conversion, for error reporting. Only present in debug mode.
-  // e.g. $art='{{=user.name}}'
-  $art: 1,
+  // e.g. $dbgArt='{{=user.name}}'
+  $dbgArt: 1,
   // Debug: source line number — tracks the current line in the template
   // source, for error reporting. Only present in debug mode.
-  $line: 1,
-  // refData alias — fallback reference lookup table.
-  // Defaults to $$ when no explicit $$ref is provided.
-  // Ensures $i() does not crash when @ operator is used without refData.
-  $$ref: 1,
+  $dbgLine: 1,
+  // RefData alias — fallback reference lookup table.
+  // Defaults to $data when no explicit $refAlt is provided.
+  // Ensures $refFn() does not crash when @ operator is used without refData.
+  $refAlt: 1,
   // Temporary variable — used by the compiler for intermediate
   // expression results in generated code (e.g. loop variables,
-  // conditional branches). Declared as: let $_temp
-  $_temp: 1,
+  // conditional branches). Declared as: let $tmp
+  $tmp: 1,
   // JS literals
   undefined: 1,
   null: 1,
@@ -5055,17 +5646,19 @@ var BUILTIN_GLOBALS = {
 };
 var BUILTIN_GLOBAL_SET = new Set(Object.keys(BUILTIN_GLOBALS));
 export {
-  Bag,
   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,
@@ -5079,13 +5672,14 @@ export {
   applyVdomOps,
   assign,
   cell,
-  classExtend,
   cloneData,
   cloneStore,
   compileTemplate,
+  computed,
   createState,
   createVdomRef,
   defineStore,
+  defineView,
   delStore,
   encodeHTML,
   encodeQ,
@@ -5093,6 +5687,7 @@ export {
   encodeURIExtra,
   ensureElementId,
   extractGlobalVars,
+  config as frameworkConfig,
   funcWithTry,
   generateId,
   getAttribute,
@@ -5100,9 +5695,9 @@ export {
   getPlatform,
   getStore,
   getUseStore,
-  has,
+  hasOwnProperty,
   installFrameVisualizerBridge,
-  isArray,
+  invalidateViewClass,
   isPlainObject,
   isPrimitive,
   isPrimitiveOrFunc,
@@ -5121,6 +5716,7 @@ export {
   observeCell,
   parseUri,
   registerViewClass,
+  resetProjectsMap,
   safeguard,
   serializeFrameTree,
   setData,
@@ -5132,6 +5728,7 @@ export {
   toUri,
   translateData,
   unmark,
+  use,
   vdomGetCompareKey,
   vdomGetNode,
   vdomSetAttributes,