@lark.js/mvc 0.0.4 → 0.0.6

package/dist/index.cjs

@@ -22,15 +22,16 @@ var index_exports = {};
 __export(index_exports, {
   CALL_BREAK_TIME: () => CALL_BREAK_TIME,
   Cache: () => Cache,
+  CrossSite: () => cross_site_default,
   EVENT_METHOD_REGEXP: () => EVENT_METHOD_REGEXP,
   EventDelegator: () => EventDelegator,
   EventEmitter: () => EventEmitter,
   Frame: () => Frame,
+  FrameVisualBridge: () => FrameVisualBridge,
   Framework: () => Framework,
   LARK_VIEW: () => LARK_VIEW,
   Payload: () => Payload,
-  Platform: () => Platform,
-  ROUTER_EVENTS: () => ROUTER_EVENTS,
+  ROUTER_EVENTS: () => RouterEvents,
   Router: () => Router,
   SPLITTER: () => SPLITTER,
   Service: () => Service,
@@ -43,59 +44,52 @@ __export(index_exports, {
   applyStyle: () => applyStyle,
   applyVdomOps: () => applyVdomOps,
   assign: () => assign,
-  cell: () => cell,
-  classExtend: () => classExtend,
-  cloneData: () => cloneData,
-  cloneStore: () => cloneStore,
+  bindStore: () => bindStore,
   compileTemplate: () => compileTemplate,
-  createState: () => createState,
+  computed: () => computed,
+  create: () => create,
   createVdomRef: () => createVdomRef,
   defineStore: () => defineStore,
-  delStore: () => delStore,
+  defineView: () => defineView,
   encodeHTML: () => encodeHTML,
   encodeQ: () => encodeQ,
   encodeSafe: () => encodeSafe,
   encodeURIExtra: () => encodeURIExtra,
   ensureElementId: () => ensureElementId,
   extractGlobalVars: () => extractGlobalVars,
+  frameworkConfig: () => config,
   funcWithTry: () => funcWithTry,
   generateId: () => generateId,
   getAttribute: () => getAttribute,
   getById: () => getById,
-  getPlatform: () => getPlatform,
-  getStore: () => getStore,
-  getUseStore: () => getUseStore,
-  has: () => has,
+  getRouteMode: () => getRouteMode,
+  hasOwnProperty: () => hasOwnProperty,
   installFrameVisualizerBridge: () => installFrameVisualizerBridge,
+  invalidateViewClass: () => invalidateViewClass,
   isPlainObject: () => isPlainObject,
   isPrimitive: () => isPrimitive,
   isPrimitiveOrFunc: () => isPrimitiveOrFunc,
-  isState: () => isState,
-  isStoreActive: () => isStoreActive,
   keys: () => keys,
-  lazySet: () => lazySet,
   mark: () => mark,
   markBooted: () => markBooted,
   markRouterBooted: () => markRouterBooted,
-  multi: () => multi,
   nextCounter: () => nextCounter,
   nodeInside: () => nodeInside,
   noop: () => noop,
   now: () => now,
-  observeCell: () => observeCell,
   parseUri: () => parseUri,
   registerViewClass: () => registerViewClass,
+  resetProjectsMap: () => resetProjectsMap,
   safeguard: () => safeguard,
   serializeFrameTree: () => serializeFrameTree,
   setData: () => setData,
-  shallowSet: () => shallowSet,
-  storeMark: () => mark2,
-  storeUnmark: () => unmark2,
   syncCounter: () => syncCounter,
   toMap: () => toMap,
   toUri: () => toUri,
   translateData: () => translateData,
   unmark: () => unmark,
+  use: () => use,
+  useUrlState: () => useUrlState,
   vdomGetCompareKey: () => vdomGetCompareKey,
   vdomGetNode: () => vdomGetNode,
   vdomSetAttributes: () => vdomSetAttributes,
@@ -108,13 +102,13 @@ module.exports = __toCommonJS(index_exports);
 
 // src/constants.ts
 var globalCounter = 0;
-var SPLITTER = "";
-var ROUTER_EVENTS = {
+var SPLITTER = String.fromCharCode(30);
+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) */
@@ -161,13 +155,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);
     }
   }
@@ -177,7 +171,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];
         }
       }
@@ -190,21 +184,22 @@ function funcWithTry(fns, args, context, configError) {
   let ret;
   for (const fn of fnArray) {
     try {
-      ret = Function.prototype.apply.call(fn, context, args);
+      ret = fn.apply(context, args);
     } catch (e) {
       configError?.(e);
     }
   }
   return ret;
 }
+var EMPTY_STRING_SET = /* @__PURE__ */ new Set();
 function setData(newData, oldData, changedKeys2, excludes) {
   let changed = false;
   for (const p in newData) {
-    if (has(newData, p)) {
+    if (hasOwnProperty(newData, p)) {
       const now2 = newData[p];
       const old = oldData[p];
       if ((!isPrimitiveOrFunc(now2) || old !== now2) && !excludes.has(p)) {
-        changedKeys2[p] = 1;
+        changedKeys2.add(p);
         changed = true;
       }
       oldData[p] = now2;
@@ -212,17 +207,25 @@ function setData(newData, oldData, changedKeys2, excludes) {
   }
   return changed;
 }
+function isRefToken(s) {
+  if (s.length < 2 || s[0] !== SPLITTER) return false;
+  for (let i = 1; i < s.length; i++) {
+    const c = s.charCodeAt(i);
+    if (c < 48 || c > 57) return false;
+  }
+  return true;
+}
 function translateData(data, value) {
   if (isPrimitive(value)) {
     const prop = String(value);
-    if (prop[0] === SPLITTER && has(data, prop)) {
+    if (isRefToken(prop) && hasOwnProperty(data, prop)) {
       return data[prop];
     }
     return value;
   }
   if (isPlainObject(value) || Array.isArray(value)) {
     for (const p in value) {
-      if (has(value, p)) {
+      if (hasOwnProperty(value, p)) {
         const val = value[p];
         const newVal = translateData(data, val);
         value[p] = newVal;
@@ -259,38 +262,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;
       }
@@ -313,14 +311,6 @@ function toMap(list, key) {
 function now() {
   return Date.now ? Date.now() : (/* @__PURE__ */ new Date()).getTime();
 }
-function classExtend(make, base, props, statics) {
-  const baseProto = base["prototype"] ?? {};
-  const classProto = Object.create(baseProto);
-  assign(classProto, props);
-  Object.assign(make, statics);
-  classProto.constructor = make;
-  make["prototype"] = classProto;
-}
 
 // src/apply-style.ts
 var injectedStyleIds = /* @__PURE__ */ new Set();
@@ -360,27 +350,35 @@ function applyStyle(styleIdOrPairs, css) {
 }
 
 // src/mark.ts
-var DELETED_KEY = SPLITTER + "$delFlag";
-var MARK_OBJECT_KEY = SPLITTER + "$markKey";
+var hostStore = /* @__PURE__ */ new WeakMap();
+function getOrCreate(host) {
+  let record = hostStore.get(host);
+  if (!record) {
+    record = { signs: /* @__PURE__ */ new Map(), deleted: false };
+    hostStore.set(host, record);
+  }
+  return record;
+}
 function mark(host, key) {
-  let sign = 0;
-  const hostRecord = host;
-  if (!hostRecord[DELETED_KEY]) {
-    const markHost = hostRecord[MARK_OBJECT_KEY] || (hostRecord[MARK_OBJECT_KEY] = {});
-    if (!Object.prototype.hasOwnProperty.call(markHost, key)) {
-      markHost[key] = 0;
-    }
-    sign = ++markHost[key];
+  const record = getOrCreate(host);
+  if (record.deleted) {
+    return () => false;
   }
+  const sign = (record.signs.get(key) ?? 0) + 1;
+  record.signs.set(key, sign);
   return () => {
-    const temp = hostRecord[MARK_OBJECT_KEY];
-    return !!(temp && sign === temp[key]);
+    const current = hostStore.get(host);
+    return !!current && !current.deleted && current.signs.get(key) === sign;
   };
 }
 function unmark(host) {
-  const hostRecord = host;
-  hostRecord[MARK_OBJECT_KEY] = 0;
-  hostRecord[DELETED_KEY] = 1;
+  const record = hostStore.get(host);
+  if (record) {
+    record.deleted = true;
+    record.signs.clear();
+  } else {
+    hostStore.set(host, { signs: /* @__PURE__ */ new Map(), deleted: true });
+  }
 }
 
 // src/safeguard.ts
@@ -409,7 +407,7 @@ function safeguard(data, getter, setter, isRoot) {
       set(target, property, value) {
         if (!setter && !prefix) {
           throw new Error(
-            "Avoid write back, key: " + prefix + property + " value:" + value + " more: https://github.com/hangtiancheng/h"
+            "Avoid write back, key: " + prefix + property + " value:" + value + " more: https://github.com/hangtiancheng/lark"
           );
         }
         Reflect.set(target, property, value);
@@ -426,7 +424,7 @@ function safeguard(data, getter, setter, isRoot) {
         if (!prefix && getter) {
           getter(property);
         }
-        if (!isRoot && has(target, property) && (Array.isArray(out) || isPlainObject(out))) {
+        if (!isRoot && hasOwnProperty(target, property) && (Array.isArray(out) || isPlainObject(out))) {
           return build(prefix + property + ".", out);
         }
         return out;
@@ -515,15 +513,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);
     }
@@ -548,20 +548,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;
     }
-    this.entries = this.entries.filter((e) => e.frequency !== -1);
+    const cmp = this.comparator;
+    const worst = [];
+    for (const entry of entries) {
+      if (worst.length < k) {
+        let i = worst.length;
+        while (i > 0 && cmp(entry, worst[i - 1]) > 0) i--;
+        worst.splice(i, 0, entry);
+      } else if (cmp(entry, worst[k - 1]) > 0) {
+        worst.pop();
+        let i = worst.length;
+        while (i > 0 && cmp(entry, worst[i - 1]) > 0) i--;
+        worst.splice(i, 0, entry);
+      }
+    }
+    const evictSet = new Set(worst);
+    for (const e of worst) {
+      this.lookup.delete(this.prefixKey(e.originalKey));
+      if (this.onRemove) this.onRemove(e.originalKey);
+    }
+    this.entries = entries.filter((e) => !evictSet.has(e));
   }
 };
 
@@ -569,6 +595,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.
    */
@@ -591,13 +621,23 @@ var EventEmitter = class {
     const key = SPLITTER + event;
     if (handler) {
       const list = this.listeners.get(key);
-      if (list) {
+      if (!list) return this;
+      if (this.firingDepth > 0) {
         for (const listener of list) {
           if (listener.handler === handler) {
             listener.handler = noop;
+            (this.pendingCompaction ??= /* @__PURE__ */ new Set()).add(key);
             break;
           }
         }
+      } else {
+        for (let i = 0; i < list.length; i++) {
+          if (list[i].handler === handler) {
+            list.splice(i, 1);
+            break;
+          }
+        }
+        if (list.length === 0) this.listeners.delete(key);
       }
     } else {
       this.listeners.delete(key);
@@ -609,9 +649,9 @@ var EventEmitter = class {
     return this;
   }
   /**
-   * Fire event, execute all bound handlers.
-   * Supports executing state management: handlers removed during
-   * execution are safely handled.
+   * Fire event, execute all bound handlers. Safe for re-entrant `off()` calls
+   * during dispatch: removed handlers are replaced with noop and compacted
+   * after the outermost fire returns.
    *
    * @param event - Event name
    * @param data - Event data (type property added automatically)
@@ -625,38 +665,41 @@ var EventEmitter = class {
       data = {};
     }
     data["type"] = event;
-    if (list) {
-      let end = list.length;
-      const len = end - 1;
-      while (end--) {
-        const idx = lastToFirst ? end : len - end;
-        const listener = list[idx];
-        if (listener.handler !== noop) {
+    this.firingDepth++;
+    try {
+      if (list) {
+        const len = list.length;
+        for (let i = 0; i < len; i++) {
+          const idx = lastToFirst ? len - 1 - i : i;
+          const listener = list[idx];
+          if (!listener) continue;
+          if (listener.handler === noop) continue;
           listener.executing = 1;
-          funcWithTry(
-            [listener.handler],
-            [data],
-            this,
-            noop
-          );
+          funcWithTry([listener.handler], [data], this, noop);
           listener.executing = "";
-        } else if (!listener.executing) {
-          list.splice(idx, 1);
         }
       }
-    }
-    const onMethodName = `on${event[0].toUpperCase() + event.slice(1)}`;
-    const onMethod = this[onMethodName];
-    if (typeof onMethod === "function") {
-      funcWithTry(
-        [onMethod],
-        [data],
-        this,
-        noop
-      );
-    }
-    if (remove) {
-      this.off(event);
+      const onMethodName = `on${event[0].toUpperCase() + event.slice(1)}`;
+      const onMethod = this[onMethodName];
+      if (typeof onMethod === "function") {
+        funcWithTry([onMethod], [data], this, noop);
+      }
+      if (remove) {
+        this.off(event);
+      }
+    } finally {
+      this.firingDepth--;
+      if (this.firingDepth === 0 && this.pendingCompaction) {
+        for (const k of this.pendingCompaction) {
+          const l = this.listeners.get(k);
+          if (!l) continue;
+          for (let i = l.length - 1; i >= 0; i--) {
+            if (l[i].handler === noop) l.splice(i, 1);
+          }
+          if (l.length === 0) this.listeners.delete(k);
+        }
+        this.pendingCompaction = void 0;
+      }
     }
     return this;
   }
@@ -665,8 +708,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();
@@ -677,7 +720,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;
@@ -687,7 +730,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);
@@ -699,35 +742,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 = {
   /**
@@ -739,7 +761,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]}`
             );
@@ -760,7 +782,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;
@@ -777,26 +799,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;
@@ -854,6 +869,8 @@ var cachedDefaultPath;
 var cachedRewrite;
 var defaultTitle;
 var frameworkConfig;
+var routeMode = "history";
+var beforeEachGuards = [];
 function createEmptyLocation() {
   return {
     href: "",
@@ -878,7 +895,8 @@ function attachViewAndPath(loc) {
     cachedRewrite = frameworkConfig.rewrite;
   }
   if (!loc.view) {
-    let path = loc.hash["path"] || cachedDefaultPath || "/";
+    const rawPath = routeMode === "history" ? loc.query["path"] || loc.hash["path"] : loc.hash["path"];
+    let path = rawPath || cachedDefaultPath || "/";
     if (cachedRewrite) {
       path = cachedRewrite(
         path,
@@ -944,7 +962,16 @@ function getChanged(oldLoc, newLoc) {
   changedCache.set(tKey, finalResult);
   return finalResult;
 }
-function updateHash(path, replace) {
+function updateBrowserUrl(path, replace) {
+  if (routeMode === "history") {
+    const url = path || "/";
+    if (replace) {
+      window.history.replaceState(null, "", url);
+    } else {
+      window.history.pushState(null, "", url);
+    }
+    return;
+  }
   const hashbang = frameworkConfig?.hashbang || "#!";
   const fullPath = path === "" ? "" : hashbang + path;
   if (replace) {
@@ -955,9 +982,10 @@ function updateHash(path, replace) {
 }
 function updateUrl(path, params, loc, replace, silentFlag, lQuery) {
   path = toUri(path, params, lQuery);
-  if (path !== loc.srcHash) {
+  const currentSrc = routeMode === "history" ? loc.srcQuery : loc.srcHash;
+  if (path !== currentSrc) {
     silent = silentFlag ? 1 : 0;
-    updateHash(path, replace);
+    updateBrowserUrl(path, replace);
   }
 }
 var Router = {
@@ -971,10 +999,29 @@ var Router = {
     if (cached) {
       return cached;
     }
-    const srcQuery = href.replace(URL_TRIM_HASH_REGEXP, "");
-    const srcHash = href.replace(URL_TRIM_QUERY_REGEXP, "");
-    const query = parseUri(srcQuery);
-    const hash = parseUri(srcHash);
+    let srcQuery;
+    let srcHash;
+    let query;
+    let hash;
+    if (routeMode === "history") {
+      try {
+        const urlObj = new URL(href, window.location.origin);
+        srcQuery = urlObj.pathname + urlObj.search;
+        srcHash = urlObj.hash ? urlObj.hash.replace(/^#!?/, "") : "";
+        query = parseUri(srcQuery);
+        hash = srcHash ? parseUri(srcHash) : { path: "", params: {} };
+      } catch {
+        srcQuery = href.replace(URL_TRIM_HASH_REGEXP, "");
+        srcHash = href.replace(URL_TRIM_QUERY_REGEXP, "");
+        query = parseUri(srcQuery);
+        hash = parseUri(srcHash);
+      }
+    } else {
+      srcQuery = href.replace(URL_TRIM_HASH_REGEXP, "");
+      srcHash = href.replace(URL_TRIM_QUERY_REGEXP, "");
+      query = parseUri(srcQuery);
+      hash = parseUri(srcHash);
+    }
     const params = assign({}, query["params"], hash["params"]);
     const location = {
       href,
@@ -1008,7 +1055,7 @@ var Router = {
         document.title = defaultTitle || document.title;
       }
       emitter2.fire(
-        ROUTER_EVENTS.CHANGED,
+        RouterEvents.CHANGED,
         lastChanged
       );
     }
@@ -1041,16 +1088,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 (routeMode === "hash" && !hasOwnProperty(window, "history")) {
+        for (const qKey of lQuery) {
+          if (!hasOwnProperty(tParams, qKey)) {
             tParams[qKey] = "";
           }
         }
@@ -1059,14 +1106,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.
@@ -1097,32 +1147,41 @@ var Router = {
     return Router;
   },
   /**
-   * Internal: bind hashchange and beforeunload events.
+   * Internal: bind routing events and beforeunload.
    * Called by Framework.boot().
+   * In hash mode, listens to hashchange + popstate.
+   * In history mode, listens to popstate only.
    */
   _bind() {
     defaultTitle = document.title;
-    let lastHash = Router.parse().srcHash;
+    const getLocationKey = () => {
+      if (routeMode === "history") {
+        return window.location.pathname + window.location.search;
+      }
+      return Router.parse().srcHash;
+    };
+    let lastKey = getLocationKey();
     let suspend;
     const watchChange = () => {
       if (suspend) {
         return;
       }
+      hrefCache.clear();
       const loc = Router.parse();
-      const newHash = loc.srcHash;
-      if (newHash !== lastHash) {
+      const newKey = routeMode === "history" ? loc.srcQuery : loc.srcHash;
+      if (newKey !== lastKey) {
         const changeEvent = {
           p: 0,
           reject: () => {
             changeEvent.p = 1;
             suspend = "";
-            updateHash(lastHash);
+            updateBrowserUrl(lastKey);
           },
           resolve: () => {
             changeEvent.p = 1;
-            lastHash = newHash;
+            lastKey = newKey;
             suspend = "";
-            updateHash(newHash);
+            updateBrowserUrl(newKey);
             Router.diff();
           },
           prevent: () => {
@@ -1130,20 +1189,51 @@ 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);
+    if (routeMode === "history") {
+      window.addEventListener("popstate", watchChange);
+    } else {
+      window.addEventListener("hashchange", watchChange);
+      window.addEventListener("popstate", watchChange);
+    }
     window.addEventListener("beforeunload", (domEvent) => {
       const data = {};
-      Router.fire(ROUTER_EVENTS.PAGE_UNLOAD, data);
+      Router.fire(RouterEvents.PAGE_UNLOAD, data);
       const msg = data["msg"];
       if (msg) {
         domEvent.returnValue = msg;
@@ -1156,11 +1246,15 @@ var Router = {
    */
   _setConfig(cfg) {
     frameworkConfig = cfg;
+    routeMode = cfg.routeMode || "history";
   }
 };
 function markRouterBooted() {
   booted2 = true;
 }
+function getRouteMode() {
+  return routeMode;
+}
 
 // src/event-delegator.ts
 var rootEvents = {};
@@ -1189,13 +1283,17 @@ function parseEventInfo(eventInfo) {
 }
 function findFrameInfo(current, eventType) {
   const eventInfos = [];
-  let begin = current;
   const info = current.getAttribute(`@${eventType}`);
+  const hasSelectorEvents = !!selectorEvents[eventType];
+  if (!info && !hasSelectorEvents) {
+    return eventInfos;
+  }
+  let begin = current;
   let match;
   if (info) {
     match = parseEventInfo(info);
   }
-  if (match && !match.id || selectorEvents[eventType]) {
+  if (match && !match.id || hasSelectorEvents) {
     let selectorFrameId = "#";
     let backtrace = 0;
     while (begin && begin !== document.body) {
@@ -1368,7 +1466,7 @@ var EventDelegator = {
 };
 
 // src/vdom.ts
-var WrapMeta = {
+var wrapMeta = {
   option: [1, "<select multiple>"],
   thead: [1, "<table>"],
   col: [2, "<table><colgroup>"],
@@ -1380,9 +1478,9 @@ var WrapMeta = {
   math: [1, '<math xmlns="' + MATH_NS + '">'],
   _: [0, ""]
 };
-WrapMeta["optgroup"] = WrapMeta["option"];
-WrapMeta["tbody"] = WrapMeta["tfoot"] = WrapMeta["colgroup"] = WrapMeta["caption"] = WrapMeta["thead"];
-WrapMeta["th"] = WrapMeta["td"];
+wrapMeta["optgroup"] = wrapMeta["option"];
+wrapMeta["tbody"] = wrapMeta["tfoot"] = wrapMeta["colgroup"] = wrapMeta["caption"] = wrapMeta["thead"];
+wrapMeta["th"] = wrapMeta["td"];
 var VDoc = document.implementation.createHTMLDocument("");
 var VBase = VDoc.createElement("base");
 VBase.href = document.location.href;
@@ -1393,16 +1491,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) {
@@ -1417,7 +1511,7 @@ function vdomGetNode(html, refNode) {
     const match = TAG_NAME_REGEXP.exec(html);
     tag = match ? match[1] : "";
   }
-  const wrap = WrapMeta[tag] || WrapMeta["_"];
+  const wrap = wrapMeta[tag] || wrapMeta["_"];
   tmp.innerHTML = wrap[1] + html;
   let j = wrap[0];
   while (j--) {
@@ -1434,7 +1528,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);
@@ -1447,8 +1541,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;
@@ -1497,13 +1590,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;
@@ -1511,7 +1608,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;
   }
@@ -1522,23 +1619,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]);
@@ -1562,17 +1661,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") || "";
@@ -1673,7 +1776,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;
@@ -1693,13 +1797,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 };
@@ -1727,7 +1837,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;
   }
   /**
@@ -1763,13 +1882,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,
@@ -1806,43 +1925,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;
@@ -1889,30 +2030,31 @@ var View = class _View {
   // ============================================================
   // Getters for prototype-stored event maps
   // ============================================================
+  /** Prototype-stored event maps shape (set by View.prepare). */
+  get protoEventState() {
+    return Object.getPrototypeOf(this);
+  }
   /**
    * Event bitmask map: eventType -> bitmask (1=root, 2=selector).
    * Read from prototype ($evtObjMap) set by View.prepare.
    * Using a getter avoids ES6 class field shadowing the prototype value.
    */
   get eventObjectMap() {
-    const proto = Object.getPrototypeOf(this);
-    return proto["$evtObjMap"] || {};
+    return this.protoEventState.$evtObjMap ?? {};
   }
   /**
    * Selector event map: eventType -> selector list.
    * Read from prototype ($selMap) set by View.prepare.
    */
   get eventSelectorMap() {
-    const proto = Object.getPrototypeOf(this);
-    return proto["$selMap"] || {};
+    return this.protoEventState.$selMap ?? {};
   }
   /**
    * Global event list: [{handler, element, eventName, modifiers}].
    * Read from prototype ($globalEvtList) set by View.prepare.
    */
   get globalEventList() {
-    const proto = Object.getPrototypeOf(this);
-    return proto["$globalEvtList"] || [];
+    return this.protoEventState.$globalEvtList ?? [];
   }
   // ============================================================
   // Instance lifecycle methods
@@ -1947,13 +2089,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);
     }
   }
   /**
@@ -1971,7 +2117,7 @@ var View = class _View {
         this.endUpdatePending = 1;
         this.rendered = true;
       }
-      const ownerFrame = this.owner;
+      const ownerFrame = this.ownerFrame;
       ownerFrame.mountZone(updateId, inner);
       if (!flag) {
         setTimeout(
@@ -2010,11 +2156,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;
       }
     }
@@ -2078,24 +2225,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) => {
@@ -2103,14 +2242,12 @@ var View = class _View {
         e["msg"] = message;
       }
     };
-    const changeFn = changeListener;
-    const unloadFn = unloadListener;
-    Router.on(ROUTER_EVENTS.CHANGE, changeFn);
-    Router.on(ROUTER_EVENTS.PAGE_UNLOAD, unloadFn);
-    this.on("unload", changeFn);
+    Router.on(RouterEvents.CHANGE, changeListener);
+    Router.on(RouterEvents.PAGE_UNLOAD, unloadListener);
+    this.on("unload", changeListener);
     this.on("destroy", () => {
-      Router.off(ROUTER_EVENTS.CHANGE, changeFn);
-      Router.off(ROUTER_EVENTS.PAGE_UNLOAD, unloadFn);
+      Router.off(RouterEvents.CHANGE, changeListener);
+      Router.off(RouterEvents.PAGE_UNLOAD, unloadListener);
     });
   }
   // ============================================================
@@ -2140,7 +2277,7 @@ var View = class _View {
       _View.mergeMixins(mixins, oView, ctors);
     }
     for (const p in proto) {
-      if (!has(proto, p)) continue;
+      if (!hasOwnProperty(proto, p)) continue;
       const currentFn = proto[p];
       if (typeof currentFn !== "function") continue;
       const matches = p.match(VIEW_EVENT_METHOD_REGEXP);
@@ -2186,16 +2323,16 @@ var View = class _View {
         const existingFn = proto[combinedKey];
         if (!existingFn) {
           proto[combinedKey] = currentFn;
-        } else {
+        } else if (typeof existingFn === "function") {
           const mixinFn = currentFn;
           const existingMixin = existingFn;
           if (existingMixin.marker) {
             if (mixinFn.marker) {
               proto[combinedKey] = _View.processMixinsSameEvent(
-                currentFn,
-                existingFn
+                mixinFn,
+                existingMixin
               );
-            } else if (has(proto, p)) {
+            } else if (hasOwnProperty(proto, p)) {
               proto[combinedKey] = currentFn;
             }
           }
@@ -2218,7 +2355,7 @@ var View = class _View {
     const selectorObject = view.eventSelectorMap;
     const eventsList = view.globalEventList;
     for (const e in eventsObject) {
-      if (has(eventsObject, e)) {
+      if (hasOwnProperty(eventsObject, e)) {
         if (destroy) {
           EventDelegator.unbind(e, !!selectorObject[e]);
         } else {
@@ -2261,7 +2398,7 @@ var View = class _View {
   static destroyAllResources(view, lastly) {
     const cache = view.resources;
     for (const p in cache) {
-      if (has(cache, p)) {
+      if (hasOwnProperty(cache, p)) {
         const entry = cache[p];
         if (lastly || entry.destroyOnRender) {
           _View.destroyResource(cache, p, true);
@@ -2291,13 +2428,16 @@ var View = class _View {
   static wrapMethod(proto, fnName, shortKey) {
     const originalFn = proto[fnName];
     if (typeof originalFn !== "function") return;
+    const originalAsFn = originalFn;
     const wrapped = function(...args) {
       if (this.signature > 0) {
         this.signature++;
         this.fire("render");
         _View.destroyAllResources(this, false);
-        const instanceFn = typeof this[fnName] === "function" ? this[fnName] : originalFn;
-        const fnToCall = instanceFn === wrapped ? originalFn : instanceFn;
+        const lookup = this;
+        const candidate = lookup[fnName];
+        const instanceFn = typeof candidate === "function" ? candidate : originalAsFn;
+        const fnToCall = instanceFn === wrapped ? originalAsFn : instanceFn;
         return funcWithTry(fnToCall, args, this, noop);
       }
       return void 0;
@@ -2311,19 +2451,18 @@ var View = class _View {
    */
   static processMixinsSameEvent(additional, exist) {
     let temp;
-    const existMixin = exist;
-    if (existMixin.handlerList) {
-      temp = existMixin;
+    if (exist.handlerList) {
+      temp = exist;
     } else {
-      temp = function(...e) {
-        funcWithTry(temp.handlerList ?? [], e, this, noop);
+      const merged = function(...e) {
+        funcWithTry(merged.handlerList ?? [], e, this, noop);
       };
-      temp.handlerList = [exist];
-      temp.marker = 1;
+      merged.handlerList = [exist];
+      merged.marker = 1;
+      temp = merged;
     }
-    const additionalMixin = additional;
     temp.handlerList = (temp.handlerList ?? []).concat(
-      additionalMixin.handlerList ?? [additional]
+      additional.handlerList ?? [additional]
     );
     return temp;
   }
@@ -2335,29 +2474,29 @@ var View = class _View {
     const temp = {};
     for (const node of mixins) {
       for (const p in node) {
-        if (!has(node, p)) continue;
+        if (!hasOwnProperty(node, p)) continue;
         const fn = node[p];
+        if (typeof fn !== "function") continue;
+        const mixinFn = fn;
         const exist = temp[p];
         if (p === "make") {
-          ctors.push(fn);
+          ctors.push(mixinFn);
           continue;
         }
         if (VIEW_EVENT_METHOD_REGEXP.test(p)) {
           if (exist) {
-            temp[p] = _View.processMixinsSameEvent(fn, exist);
+            temp[p] = _View.processMixinsSameEvent(mixinFn, exist);
           } else {
-            fn.marker = 1;
-            temp[p] = fn;
-          }
-        } else {
-          if (!exist) {
-            temp[p] = fn;
+            mixinFn.marker = 1;
+            temp[p] = mixinFn;
           }
+        } else if (!exist) {
+          temp[p] = mixinFn;
         }
       }
     }
     for (const p in temp) {
-      if (!has(proto, p)) {
+      if (!hasOwnProperty(proto, p)) {
         proto[p] = temp[p];
       }
     }
@@ -2390,19 +2529,20 @@ var View = class _View {
    * - Event method patterns: `'name<click>'` etc.
    */
   static extend(props, statics) {
-    props = props || {};
-    const make = props["make"];
+    const definedProps = props ?? {};
+    const make = definedProps["make"];
     const ctors = [];
-    if (make) {
+    if (typeof make === "function") {
       ctors.push(make);
     }
     const ParentView = this;
     const ChildView = class extends ParentView {
       constructor(nodeId, ownerFrame, initParams, node, mixinCtors) {
         super(nodeId, ownerFrame, initParams, node, []);
-        for (const key in props) {
-          if (has(props, key) && key !== "make" && key !== "render") {
-            this[key] = props[key];
+        const instanceProps = this;
+        for (const key in definedProps) {
+          if (hasOwnProperty(definedProps, key) && key !== "make" && key !== "render") {
+            instanceProps[key] = definedProps[key];
           }
         }
         this.id = nodeId;
@@ -2422,15 +2562,16 @@ var View = class _View {
       }
     };
     const proto = ChildView.prototype;
-    for (const key in props) {
-      if (has(props, key) && key !== "make") {
-        proto[key] = props[key];
+    for (const key in definedProps) {
+      if (hasOwnProperty(definedProps, key) && key !== "make") {
+        proto[key] = definedProps[key];
       }
     }
     if (statics) {
+      const staticTarget = ChildView;
       for (const key in statics) {
-        if (has(statics, key)) {
-          ChildView[key] = statics[key];
+        if (hasOwnProperty(statics, key)) {
+          staticTarget[key] = statics[key];
         }
       }
     }
@@ -2445,14 +2586,87 @@ var View = class _View {
     return this;
   }
 };
+function defineView(props, statics) {
+  return View.extend(props, statics);
+}
+
+// src/module-loader.ts
+var config = {
+  rootId: "root",
+  routeMode: "history",
+  hashbang: "#!",
+  error: (error) => {
+    throw error;
+  }
+};
+function use(names, callback) {
+  const nameList = typeof names === "string" ? [names] : names;
+  const loadPromise = (() => {
+    if (config.require) {
+      const result = config.require(nameList);
+      if (result && typeof result.then === "function") {
+        return result;
+      }
+      return Promise.resolve([]);
+    }
+    return Promise.all(
+      nameList.map((name) => {
+        const importPath = name.startsWith(".") || name.startsWith("/") ? name : `./${name}`;
+        return import(
+          /* @vite-ignore */
+          /* webpackIgnore: true */
+          importPath
+        ).then((mod) => {
+          return mod && (mod["__esModule"] || // For Webpack
+          typeof mod["default"] === "function") ? mod["default"] : mod;
+        }).catch((err) => {
+          const errorHandler = config.error;
+          if (errorHandler) {
+            errorHandler(err instanceof Error ? err : new Error(String(err)));
+          }
+          return void 0;
+        });
+      })
+    );
+  })();
+  if (callback) {
+    loadPromise.then((modules) => {
+      callback(...modules);
+    });
+  }
+  return loadPromise;
+}
+
+// src/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;
@@ -2467,8 +2681,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) */
@@ -2539,13 +2753,30 @@ var Frame = class _Frame extends EventEmitter {
     this.viewPath = viewPath;
     const params = parsed["params"];
     translateQuery(pId || this.id, viewPath, params);
+    const initParams = { ...params };
     if (viewInitParams) {
-      assign(params, viewInitParams);
+      assign(initParams, viewInitParams);
     }
     const sign = this.signature;
-    if (viewClassRegistry[viewClassName]) {
-      this.doMountView(viewClassRegistry[viewClassName], params, node, sign);
+    const registered = getViewClass(viewClassName);
+    if (registered) {
+      this.doMountView(registered, initParams, node, sign);
+      return;
     }
+    use(viewClassName, (ViewClass) => {
+      if (sign !== this.signature) return;
+      if (typeof ViewClass === "function") {
+        const ViewClassTyped = ViewClass;
+        registerViewClass(viewClassName, ViewClassTyped);
+        this.doMountView(ViewClassTyped, initParams, node, sign);
+      } else {
+        const error = new Error(`Cannot load view: ${viewClassName}`);
+        const errorHandler = config.error;
+        if (errorHandler) {
+          errorHandler(error);
+        }
+      }
+    });
   }
   /**
    * Internal: actually mount the view after class is loaded.
@@ -2553,14 +2784,8 @@ var Frame = class _Frame extends EventEmitter {
   doMountView(ViewClass, params, node, sign) {
     if (sign !== this.signature) return;
     const mixinCtors = View.prepare(ViewClass);
-    const ViewConstructor = ViewClass;
-    const view = new ViewConstructor(
-      this.id,
-      this,
-      params,
-      node,
-      mixinCtors
-    );
+    const Ctor = ViewClass;
+    const view = new Ctor(this.id, this, params, node, mixinCtors);
     this.viewInstance = view;
     view.signature = 1;
     View.delegateEvents(view);
@@ -2641,7 +2866,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);
@@ -2660,13 +2887,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);
@@ -2679,7 +2905,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);
         }
@@ -2693,7 +2919,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);
       }
     }
@@ -2720,14 +2946,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;
@@ -2750,6 +2972,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
   // ============================================================
@@ -2761,8 +3002,25 @@ var Frame = class _Frame extends EventEmitter {
   static getAll() {
     return frameRegistry;
   }
-  /** Get or create root frame */
-  static root(rootId) {
+  /**
+   * Returns the existing root frame, or `undefined` if none has been created.
+   * Pure getter — never creates a Frame, never touches the DOM.
+   *
+   * Use `Frame.createRoot(id)` to create the root explicitly during framework
+   * boot. For Micro-Frontend hosts that own multiple independent containers,
+   * use `new Frame(containerId)` directly so each MF mount has its own root.
+   */
+  static getRoot() {
+    return rootFrame;
+  }
+  /**
+   * Create (or return) the singleton root frame for this app.
+   *
+   * Idempotent: subsequent calls always return the original root regardless
+   * of `rootId` — so passing a different id later is silently ignored.
+   * `Framework.boot()` is the canonical caller; user code rarely needs this.
+   */
+  static createRoot(rootId) {
     if (!rootFrame) {
       rootId = rootId || "root";
       let rootElement = document.getElementById(rootId);
@@ -2774,6 +3032,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);
@@ -2789,6 +3058,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;
@@ -2818,8 +3090,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);
       }
@@ -2834,9 +3106,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);
       }
     }
@@ -2849,7 +3121,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);
 }
@@ -2857,7 +3129,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);
@@ -2867,22 +3139,138 @@ function translateQuery(pId, src, params) {
   if (!parentRefData) return;
   if (src.indexOf(SPLITTER) > 0) {
     translateData(parentRefData, params);
-    if (params[SPLITTER]) {
-      assign(
-        params,
-        params[SPLITTER]
-      );
+    const paramsRec = params;
+    const splitterValue = paramsRec[SPLITTER];
+    if (splitterValue && typeof splitterValue === "object") {
+      assign(params, splitterValue);
       Reflect.deleteProperty(params, SPLITTER);
     }
   }
 }
-function registerViewClass(viewPath, ViewClass) {
-  const parsed = parseUri(viewPath);
-  const path = parsed.path;
-  if (path) {
-    viewClassRegistry[path] = ViewClass;
+
+// src/cross-site.ts
+var preparePromises = {};
+var projectsMap = null;
+function loadRemoteView(viewPath, bizCode) {
+  const crossConfigs = config.crossConfigs || window.crossConfigs;
+  const currentName = config.projectName || "";
+  const slashIndex = viewPath.indexOf("/");
+  const projectName = slashIndex > -1 ? viewPath.substring(0, slashIndex) : viewPath;
+  if (projectName === currentName) return Promise.resolve();
+  if (!preparePromises[projectName]) {
+    if (!projectsMap) {
+      const map = toMap(crossConfigs || [], "projectName");
+      projectsMap = map;
+    }
+    const info = projectsMap[projectName];
+    if (!info) {
+      return Promise.reject(
+        new Error(`Cannot find ${projectName} from crossConfigs`)
+      );
+    }
+    preparePromises[projectName] = use(`${projectName}/prepare`).then((modules) => {
+      let mod = modules[0];
+      if (mod && typeof mod === "object" && mod !== null) {
+        const rec = mod;
+        if (rec["__esModule"]) {
+          mod = rec["default"];
+        }
+      }
+      if (typeof mod === "function") {
+        return mod({ bizCode });
+      }
+      return void 0;
+    }).catch((err) => {
+      Reflect.deleteProperty(preparePromises, projectName);
+      throw err;
+    });
   }
+  return preparePromises[projectName];
 }
+function resetProjectsMap() {
+  projectsMap = null;
+}
+var skeletonTemplate = (data, viewId) => {
+  let skeletonHtml = "<div>Loading...</div>";
+  if (data && typeof data === "object") {
+    const candidate = data.skeleton;
+    if (typeof candidate === "string") skeletonHtml = candidate;
+  }
+  return `<div id="mf_${viewId}">${skeletonHtml}</div>`;
+};
+var CrossSite = View.extend({
+  /** Skeleton template renders loading state + child container */
+  template: skeletonTemplate,
+  init(params) {
+    this.$sign = 0;
+    this.on("destroy", () => {
+      this.$sign = -1;
+    });
+    this.assign?.(params);
+  },
+  assign(data) {
+    this.$view = typeof data["view"] === "string" ? data["view"] : "";
+    const nested = data["params"];
+    const nestedParams = nested && typeof nested === "object" ? nested : {};
+    this.$params = { ...data, ...nestedParams };
+    this.updater.set({
+      skeleton: data["skeleton"],
+      skeletonParams: data["skeletonParams"] || {},
+      bizCode: data["bizCode"]
+    });
+    if (this.$sign > 0) {
+      this.updateView();
+    }
+    return false;
+  },
+  async updateView() {
+    const sign = ++this.$sign;
+    const stored = this.updater.get();
+    const bizCode = stored.bizCode;
+    try {
+      await loadRemoteView(this.$view, bizCode);
+    } catch (ex) {
+      const node = document.getElementById("mf_" + this.id);
+      if (node) {
+        const err = ex instanceof Error ? ex : new Error(String(ex));
+        node.innerHTML = err.message || String(err);
+      }
+    }
+    if (this.$sign !== sign) return;
+    const mf = Frame.get("mf_" + this.id);
+    const parsedNew = parseUri(this.$view);
+    const newPath = parsedNew.path;
+    const oldPath = mf?.viewPath ? parseUri(mf.viewPath).path : "";
+    const view = mf?.view;
+    if (newPath === oldPath && view && typeof view.assign === "function") {
+      const result = funcWithTry(view.assign, [this.$params], view, noop);
+      if (result) {
+        view.render();
+      }
+      return;
+    }
+    const owner = this.owner;
+    if (owner && typeof owner !== "number") {
+      owner.mountFrame("mf_" + this.id, this.$view, this.$params);
+    }
+  },
+  render() {
+    const params = this.$params;
+    this.updater.digest({
+      skeleton: params?.["skeleton"]
+    });
+    this.updateView();
+  },
+  /**
+   * Invoke a method on the remote view.
+   * Usage: mf.invoke('callView', methodName, ...args)
+   */
+  callView(name, ...args) {
+    const mf = Frame.get("mf_" + this.id);
+    return mf?.invoke(name, args);
+  }
+});
+var cross_site_default = CrossSite;
 
 // src/service.ts
 var Payload = class {
@@ -3070,29 +3458,31 @@ var Service = class {
    * Get metadata for an API endpoint.
    */
   static meta(attrs) {
-    const name = typeof attrs === "string" ? attrs : attrs["name"];
-    return this._metaList[name] || attrs;
+    const name = typeof attrs === "string" ? attrs : String(attrs["name"] ?? "");
+    const known = this._metaList[name];
+    if (known) return known;
+    return attrs;
   }
   /**
    * Create a Payload for an API request.
    */
   static create(attrs) {
     const meta = this.meta(attrs);
-    const cache = attrs["cache"] | 0 || meta.cache || 0;
+    const cache = toCacheValue(attrs["cache"]) || meta.cache || 0;
     const entity = new Payload();
     entity.set(meta);
     entity.cacheInfo = {
       name: meta.name,
-      after: meta.after,
-      cleans: meta.cleanKeys,
+      after: typeof meta.after === "function" ? meta.after : void 0,
+      cleans: typeof meta.cleanKeys === "string" ? meta.cleanKeys : void 0,
       key: cache ? defaultCacheKey(meta, attrs) : "",
       time: 0
     };
-    if (typeof attrs === "object" && attrs !== null) {
+    if (attrs !== null) {
       entity.set(attrs);
     }
     const before = meta.before;
-    if (before) {
+    if (typeof before === "function") {
       funcWithTry(before, [entity], entity, noop);
     }
     this._staticEmitter.fire("begin", { payload: entity });
@@ -3118,7 +3508,7 @@ var Service = class {
    */
   static cached(attrs) {
     const meta = this.meta(attrs);
-    const cache = attrs["cache"] | 0 || meta.cache || 0;
+    const cache = toCacheValue(attrs["cache"]) || meta.cache || 0;
     let cacheKey = "";
     if (cache) {
       cacheKey = defaultCacheKey(meta, attrs);
@@ -3126,7 +3516,8 @@ var Service = class {
     if (cacheKey) {
       const info = this._pendingCacheKeys[cacheKey];
       if (info) {
-        return info.entity;
+        const entity = info.entity;
+        return entity instanceof Payload ? entity : void 0;
       }
       const cached = this._payloadCache.get(cacheKey);
       if (cached && cached.cacheInfo) {
@@ -3143,17 +3534,14 @@ var Service = class {
    * Clear cached payloads by endpoint name.
    */
   static clear(names) {
-    const nameList = (typeof names === "string" ? names : names.join(",")).split(",");
-    const nameSet = {};
-    for (const n of nameList) {
-      nameSet[n] = 1;
-    }
+    const nameSet = new Set(
+      (typeof names === "string" ? names : names.join(",")).split(",")
+    );
     const keysToDelete = [];
     this._payloadCache.forEach((payload) => {
-      if (payload?.cacheInfo && nameSet[payload.cacheInfo.name]) {
-        if (payload.cacheInfo.key) {
-          keysToDelete.push(payload.cacheInfo.key);
-        }
+      const info = payload?.cacheInfo;
+      if (info && info.key && nameSet.has(info.name)) {
+        keysToDelete.push(info.key);
       }
     });
     for (const key of keysToDelete) {
@@ -3172,12 +3560,23 @@ var Service = class {
   }
   /**
    * Create a new Service subclass with a custom sync function.
-   * Each subclass gets its own per-type state (metaList, cache, etc.)
-   * to ensure isolation between different Service types.
+   *
+   * Each subclass gets its OWN copies of every per-type static field
+   * (`_metaList`, `_payloadCache`, `_pendingCacheKeys`, `_syncFn`,
+   * `_staticEmitter`, `_cacheMax`, `_cacheBuffer`) via `static override`.
+   * This is intentional: it ensures that endpoint metadata, cache state,
+   * in-flight dedup keys, and event subscribers are fully isolated between
+   * different Service types, even when one extends another.
+   *
+   * **Do not refactor these `static override` declarations away** — sharing
+   * them through prototype inheritance would let endpoints registered on one
+   * subclass leak into another, and the LFU cache evictions of one type
+   * would race with those of another.
    */
   static extend(newSyncFn, newCacheMax, newCacheBuffer) {
     const ParentService = this;
     class ChildService extends ParentService {
+      // Intentionally per-subclass — see Service.extend doc.
       static _metaList = {};
       static _payloadCache = new Cache({
         maxSize: newCacheMax || ParentService._cacheMax,
@@ -3192,18 +3591,34 @@ var Service = class {
     return ChildService;
   }
 };
+var metaJsonCache = /* @__PURE__ */ new WeakMap();
+function getMetaJson(meta) {
+  let cached = metaJsonCache.get(meta);
+  if (cached === void 0) {
+    cached = JSON.stringify(meta);
+    metaJsonCache.set(meta, cached);
+  }
+  return cached;
+}
 function defaultCacheKey(meta, attrs) {
-  return JSON.stringify(attrs) + SPLITTER + JSON.stringify(meta);
+  return JSON.stringify(attrs) + SPLITTER + getMetaJson(meta);
+}
+function toCacheValue(v) {
+  if (typeof v === "number") return v | 0;
+  if (typeof v === "string") {
+    const n = Number(v);
+    return Number.isFinite(n) ? n | 0 : 0;
+  }
+  return 0;
 }
 function serviceSend(service, attrs, done, flag, save) {
-  if (service["destroyed"]) return;
-  if (service["busy"]) {
-    service.enqueue(
-      serviceSend.bind(null, service, attrs, done, flag, save)
-    );
+  if (service.destroyed) return;
+  if (service.busy) {
+    const queued = () => serviceSend(service, attrs, done, flag, save);
+    service.enqueue(queued);
     return;
   }
-  service["busy"] = 1;
+  service.busy = 1;
   let attrList;
   if (typeof attrs === "string") {
     attrList = [{ name: attrs }];
@@ -3228,10 +3643,10 @@ function serviceSend(service, attrs, done, flag, save) {
       newPayload = true;
       staticEmitter2.fire("done", { payload });
     }
-    if (!service["destroyed"]) {
+    if (!service.destroyed) {
       const finish = requestCount === total;
       if (finish) {
-        service["busy"] = 0;
+        service.busy = 0;
         if (flag === FETCH_FLAGS_ALL) {
           doneArr[0] = errorArgs;
           funcWithTry(done, doneArr, service, noop);
@@ -3248,10 +3663,7 @@ function serviceSend(service, attrs, done, flag, save) {
   for (const attr of attrList) {
     if (!attr) continue;
     const attrObj = typeof attr === "string" ? { name: attr } : attr;
-    const payloadInfo = service.type.get(
-      attrObj,
-      save
-    );
+    const payloadInfo = service.type.get(attrObj, save);
     const payloadEntity = payloadInfo.entity;
     const cacheKey = payloadEntity.cacheInfo?.key || "";
     const complete = remoteComplete.bind(null, requestCount++);
@@ -3265,15 +3677,13 @@ function serviceSend(service, attrs, done, flag, save) {
         const cacheComplete = () => {
           const list = pendingCacheKeys[cacheKey];
           const entity = list.entity;
-          if (entity.cacheInfo) {
+          if (entity instanceof Payload && entity.cacheInfo) {
             entity.cacheInfo.time = now();
+            internals.payloadCache.set(cacheKey, entity);
           }
-          internals.payloadCache.set(cacheKey, entity);
           Reflect.deleteProperty(pendingCacheKeys, cacheKey);
           for (const cb of list) {
-            if (typeof cb === "function") {
-              cb();
-            }
+            if (typeof cb === "function") cb();
           }
         };
         syncFn(payloadEntity, cacheComplete);
@@ -3286,13 +3696,32 @@ function serviceSend(service, attrs, done, flag, save) {
   }
 }
 
-// src/frame-visualizer.ts
-var MSG_PING = "LARK_VISUALIZER_PING";
-var MSG_PONG = "LARK_VISUALIZER_PONG";
-var MSG_REQUEST_TREE = "LARK_VISUALIZER_REQUEST_TREE";
-var MSG_TREE = "LARK_VISUALIZER_TREE";
-var MSG_TREE_DELTA = "LARK_VISUALIZER_TREE_DELTA";
+// src/frame-visual.ts
+var FrameVisualBridge = {
+  MSG_PING: "LARK_VIS_PING",
+  MSG_PONG: "LARK_VIS_PONG",
+  MSG_REQUEST_TREE: "LARK_VIS_REQUEST_TREE",
+  MSG_TREE: "LARK_VIS_TREE",
+  MSG_TREE_DELTA: "LARK_VIS_TREE_DELTA"
+};
 function serializeView(view) {
+  const evtMap = view.eventObjectMap;
+  const eventMethodKeys = evtMap ? Object.keys(evtMap) : [];
+  const resourceKeys = view.resources ? Object.keys(view.resources) : [];
+  const lookup = view;
+  const hasAssign = typeof lookup["assign"] === "function";
+  let updaterData = null;
+  try {
+    const ref = view.updater?.refData;
+    if (ref && typeof ref === "object") {
+      updaterData = {};
+      for (const k of Object.keys(ref)) {
+        const v = ref[k];
+        updaterData[k] = v === null || typeof v !== "object" ? v : `[${typeof v}]`;
+      }
+    }
+  } catch {
+  }
   return {
     id: view.id,
     rendered: !!view.rendered,
@@ -3303,7 +3732,11 @@ function serializeView(view) {
       keys: view.locationObserved.keys,
       observePath: view.locationObserved.observePath
     },
-    hasTemplate: !!view.template
+    hasTemplate: !!view.template,
+    eventMethodKeys,
+    resourceKeys,
+    hasAssign,
+    updaterData
   };
 }
 function serializeFrame(frameId) {
@@ -3331,7 +3764,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) => {
@@ -3359,19 +3795,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: "*" }
         );
       }
@@ -3390,18 +3829,14 @@ function pushTreeUpdate() {
   const treeJson = JSON.stringify(tree);
   if (treeJson !== lastTreeJson) {
     lastTreeJson = treeJson;
-    window.parent.postMessage({ type: MSG_TREE_DELTA, data: tree }, "*");
+    window.parent.postMessage(
+      { type: FrameVisualBridge.MSG_TREE_DELTA, data: tree },
+      "*"
+    );
   }
 }
 
 // src/framework.ts
-var config = {
-  rootId: "root",
-  hashbang: "#!",
-  error: (error) => {
-    throw error;
-  }
-};
 var booted3 = false;
 var taskList = [];
 var taskIndex = 0;
@@ -3450,6 +3885,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;
@@ -3463,7 +3901,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;
         }
       }
@@ -3475,48 +3913,59 @@ function stateIsObserveChanged(view, stateKeys) {
   const observedKeys = view.observedStateKeys;
   if (!observedKeys) return false;
   for (const key of observedKeys) {
-    if (has(stateKeys, key)) return true;
+    if (stateKeys.has(key)) return true;
   }
   return false;
 }
 function dispatcherUpdate(frame, stateKeys) {
-  const frameInternal = frame;
-  const view = frame.view;
-  if (!view || frameInternal.dispatcherUpdateTag === dispatcherUpdateTag || view.signature <= 1) {
-    return;
-  }
-  frameInternal.dispatcherUpdateTag = dispatcherUpdateTag;
-  const isChanged = stateKeys ? stateIsObserveChanged(view, stateKeys) : viewIsObserveChanged(view);
-  let renderPromise;
-  if (isChanged) {
-    const renderResult = funcWithTry(
-      view.renderMethod ?? view.render,
-      [],
-      view,
-      noop
-    );
-    if (renderResult && typeof renderResult.then === "function") {
-      renderPromise = renderResult;
-    }
-  }
-  const children = frame.children();
-  const recurse = () => {
-    for (const childId of children) {
-      const childFrame = Frame.get(childId);
-      if (childFrame) {
-        dispatcherUpdate(childFrame, stateKeys);
+  const stack = [frame];
+  const drain = (s) => {
+    while (s.length > 0) {
+      const current = s.pop();
+      const tagged = current;
+      const view = current.view;
+      if (!view || tagged.dispatcherUpdateTag === dispatcherUpdateTag || view.signature <= 1) {
+        continue;
+      }
+      tagged.dispatcherUpdateTag = dispatcherUpdateTag;
+      const isChanged = stateKeys ? stateIsObserveChanged(view, stateKeys) : viewIsObserveChanged(view);
+      let renderPromise;
+      if (isChanged) {
+        const renderResult = funcWithTry(
+          view.renderMethod ?? view.render,
+          [],
+          view,
+          noop
+        );
+        if (isThenable(renderResult)) {
+          renderPromise = renderResult;
+        }
+      }
+      const children = current.children();
+      if (renderPromise) {
+        renderPromise.then(() => {
+          const subStack = [];
+          for (let i = children.length - 1; i >= 0; i--) {
+            const child = Frame.get(children[i]);
+            if (child) subStack.push(child);
+          }
+          drain(subStack);
+        });
+      } else {
+        for (let i = children.length - 1; i >= 0; i--) {
+          const child = Frame.get(children[i]);
+          if (child) s.push(child);
+        }
       }
     }
   };
-  if (renderPromise) {
-    renderPromise.then(recurse);
-  } else {
-    recurse();
-  }
+  drain(stack);
 }
 function dispatcherNotifyChange(e) {
-  const rootFrame2 = Frame.root();
-  const view = e.view;
+  const rootFrame2 = Frame.getRoot();
+  if (!rootFrame2) return;
+  const routeEvent = e;
+  const view = routeEvent.view;
   if (view) {
     const viewPath = typeof view === "object" && view !== null ? String(view.to || "") : String(view);
     rootFrame2.mountView(viewPath);
@@ -3533,19 +3982,6 @@ function dispatchEvent(target, eventType, eventInit) {
   });
   target.dispatchEvent(event);
 }
-function use(names, callback) {
-  if (!config.require) {
-    if (callback) callback();
-    return;
-  }
-  const nameList = typeof names === "string" ? [names] : names;
-  const result = config.require(nameList);
-  if (result && typeof result.then === "function") {
-    result.then((modules) => {
-      if (callback) callback(modules);
-    });
-  }
-}
 var WAIT_OK = 1;
 var WAIT_TIMEOUT_OR_NOT_FOUND = 0;
 function waitZoneViewsRendered(viewId, timeout) {
@@ -3568,12 +4004,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) {
@@ -3594,17 +4045,17 @@ var Framework = {
     }
     Router._setConfig(config);
     EventDelegator.setFrameGetter((id) => Frame.get(id));
-    Router.on(ROUTER_EVENTS.CHANGED, (data) => {
+    Router.on(RouterEvents.CHANGED, (data) => {
       if (data) dispatcherNotifyChange(data);
     });
-    State.on(ROUTER_EVENTS.CHANGED, (data) => {
+    State.on(RouterEvents.CHANGED, (data) => {
       if (data) dispatcherNotifyChange(data);
     });
     booted3 = true;
     markBooted();
     markRouterBooted();
     installFrameVisualizerBridge();
-    const rootFrame2 = Frame.root(config.rootId);
+    const rootFrame2 = Frame.createRoot(config.rootId);
     Router._bind();
     const defaultView = config.defaultView || "";
     if (defaultView && !rootFrame2.view) {
@@ -3659,7 +4110,7 @@ var Framework = {
   /**
    * Check if object has own property.
    */
-  has,
+  has: hasOwnProperty,
   /**
    * Get object keys.
    */
@@ -3719,846 +4170,166 @@ if (typeof window !== "undefined") {
   window.__lark_Router = Router;
   window.__lark_Frame = Frame;
   window.__lark_View = View;
+  window.__lark_invalidateViewClass = invalidateViewClass;
+  window.__lark_getViewClassRegistry = getViewClassRegistry;
+  window.__lark_registerViewClass = registerViewClass;
 }
 
-// src/store.ts
-var LARK_GLOBAL = "lark-global";
-var Platform = /* @__PURE__ */ ((Platform2) => {
-  Platform2["Lark"] = "lark";
-  Platform2["React"] = "react";
-  Platform2["Node"] = "node";
-  return Platform2;
-})(Platform || {});
-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) => {
-  if (!obj || !isObject(obj)) return {};
-  const newData = Array.isArray(obj) ? [] : Object.create(Object.getPrototypeOf(obj));
-  for (const key in obj) {
-    if (hasOwnProperty(obj, key)) {
-      const value = obj[key];
-      newData[key] = isObject(value) ? deepClone(value) : value;
-    }
-  }
-  return newData;
-};
-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];
-  }
-  return data;
-};
-var Queue = class {
-  pendingTasks = /* @__PURE__ */ new Set();
-  queue = [];
-  flushTasks() {
-    const { pendingTasks, queue } = this;
-    const flushTickTask = () => {
-      while (queue.length > 0) {
-        const task2 = queue.shift();
-        if (task2) {
-          pendingTasks.delete(task2);
-          runTask(task2);
-        }
-      }
-    };
-    Promise.resolve().then(flushTickTask);
-  }
-  add(tasks) {
-    const isQueueEmpty = this.queue.length === 0;
-    for (const { cb, params } of tasks) {
-      addParams2Callback(cb, params);
-      if (!this.pendingTasks.has(cb)) {
-        this.queue.push(cb);
-        this.pendingTasks.add(cb);
-      }
+// src/url-state.ts
+function useUrlState(view, initialState) {
+  const keys2 = initialState ? Object.keys(initialState) : [];
+  if (keys2.length > 0) {
+    view.observeLocation(keys2);
+  }
+  const getState = () => {
+    const loc = Router.parse();
+    const result = { ...initialState || {} };
+    for (const key of keys2) {
+      const val = loc.get(key);
+      if (val) result[key] = val;
     }
-    if (isQueueEmpty) this.flushTasks();
-  }
-  delete(tasks) {
-    if (this.pendingTasks.size === 0) return;
-    for (const { cb } of tasks) {
-      if (this.pendingTasks.has(cb)) {
-        this.pendingTasks.delete(cb);
-        const index = this.queue.findIndex((item) => item === cb);
-        if (index !== -1) this.queue.splice(index, 1);
-      }
-    }
-  }
-  clear() {
-    this.queue = [];
-    this.pendingTasks.clear();
-  }
-};
-var addParams2Callback = (cb, params) => {
-  if (!cb || !params) return;
-  const cbObj = cb;
-  if (isObject(cb) && isObject(cbObj["params"])) {
-    Object.assign(cbObj["params"], params);
-  } else {
-    cbObj["params"] = params;
-  }
-};
-var runTask = (cb) => {
-  const cbObj = cb;
-  const params = cbObj["params"];
-  delete cbObj["params"];
-  try {
-    cb(params);
-  } catch {
-  }
-};
-var getDefScheduler = () => new Queue();
-var run = (tasks, scheduler) => {
-  if (scheduler) {
-    if (isFunction(scheduler)) {
-      for (const { cb, params } of tasks) scheduler(cb, params);
-    } else {
-      scheduler.add(tasks);
-    }
-  } else {
-    for (const { cb, params } of tasks) cb(params);
-  }
-};
-var ArrMethods = {};
-["indexOf", "lastIndexOf", "includes"].forEach((key) => {
-  const rawMethod = Array.prototype[key];
-  ArrMethods[key] = function(...args) {
-    let res = rawMethod.apply(this, args);
-    if (res === -1 || res === false) {
-      res = rawMethod.apply(
-        this,
-        args.map((item) => ProxyCache.get(item) ?? item)
-      );
-    }
-    return res;
-  };
-});
-var inArrUpdate = false;
-["unshift", "shift", "push", "pop", "splice"].forEach((key) => {
-  const rawMethod = Array.prototype[key];
-  ArrMethods[key] = function(...args) {
-    inArrUpdate = true;
-    const result = rawMethod.apply(this, args);
-    inArrUpdate = false;
     return result;
   };
-});
-function needKeepArrItem(target, newVal, key) {
-  if (!Array.isArray(target) || !inArrUpdate) return false;
-  return getLinkKeys(newVal) === createLinkKeys(target, key);
-}
-var defStateConfig = {
-  belong: LARK_GLOBAL,
-  linkKeys: "",
-  shallow: false
-};
-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;
-  }
-  const config2 = StateConfigMap.get(target);
-  return key ? config2?.[key] : config2;
-};
-var isState = (target) => isObject(target) && StateConfigMap.has(target);
-var createLinkKeys = (target, property) => {
-  if (!hasLinkKeys(target)) return property;
-  if (Array.isArray(target)) return getLinkKeys(target) ?? property;
-  return `${getLinkKeys(target)}.${property}`;
-};
-var formatLinkKeys = (target, key) => {
-  const originKeysStr = getLinkKeys(target);
-  if (!originKeysStr) return null;
-  const linkKeys = [];
-  const originKeys = originKeysStr.split(".");
-  let pre = "";
-  for (const k of originKeys) {
-    const curr = pre ? `${pre}.${k}` : k;
-    linkKeys.push(curr);
-    pre = curr;
-  }
-  linkKeys.push(`${originKeysStr}.${key}`);
-  return linkKeys;
-};
-var getLinkKeys = (target) => getStateConfig(target, "linkKeys");
-var hasLinkKeys = (target) => !!getLinkKeys(target);
-var ProxyCache = /* @__PURE__ */ new WeakMap();
-var keepKey = null;
-var keep = (key) => {
-  if (keepKey) throw new Error("[lark-store] keepKey is not null");
-  keepKey = key;
-};
-var needKeep = (key) => {
-  if (keepKey === key) {
-    keepKey = null;
-    return true;
-  }
-  return false;
-};
-var canSetNewVal = (params) => {
-  const { property, newVal, oldVal } = params;
-  if (hasOwnProperty(params.target, property) && newVal === oldVal)
-    return false;
-  return true;
-};
-var getNewVal = (params) => {
-  const { target, newVal, property, needKeepVal = false } = params;
-  const config2 = getStateConfig(target);
-  if (!isObject(newVal)) return newVal;
-  if (needKeepArrItem(target, newVal, property)) return newVal;
-  if (config2?.shallow) return newVal;
-  if (needKeepVal) return newVal;
-  const linkKeys = createLinkKeys(target, property);
-  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;
-  return {
-    belong: config2.belong || LARK_GLOBAL,
-    target,
-    keys: formatLinkKeys(target, property) || [property],
-    newVal,
-    oldVal
-  };
-};
-var handlePromise = (child, parent, key) => {
-  child.then((res) => {
-    const parentProxy = ProxyCache.get(parent);
-    if (parentProxy) {
-      const oldVal = parentProxy[key];
-      if (ProxyCache.get(child) === oldVal) {
-        parentProxy[key] = res;
-      }
-    }
-  }).catch((err) => {
-    const parentProxy = ProxyCache.get(parent);
-    if (parentProxy) {
-      const oldVal = parentProxy[key];
-      if (ProxyCache.get(child) === oldVal) {
-        parentProxy[key] = err;
-      }
-    }
-  });
-};
-var _deleteKey = "_delete";
-var _markObjKey = "_markObj";
-var mark2 = (host, key) => {
-  let sign;
-  if (!host[_deleteKey]) {
-    const markHost = host[_markObjKey] || (host[_markObjKey] = {});
-    if (!hasOwnProperty(markHost, key)) {
-      markHost[key] = 0;
-    }
-    sign = ++markHost[key];
-  }
-  return () => {
-    const temp = host[_markObjKey];
-    return !!temp && sign === temp[key];
+  const setState = (patch) => {
+    const current = getState();
+    const resolved = typeof patch === "function" ? patch(current) : patch;
+    Router.to(resolved);
   };
-};
-var unmark2 = (host) => {
-  host[_deleteKey] = 1;
-  host[_markObjKey] = 0;
-};
-function createState(initialData, config2) {
-  if (!isObject(initialData)) return initialData;
-  const mergedConfig = Object.assign({ ...defStateConfig }, config2);
-  const data = Array.isArray(initialData) ? [] : Object.create(Object.getPrototypeOf(initialData));
-  const handler = {
-    get(target, property, _receiver) {
-      if (Array.isArray(target) && property in ArrMethods) {
-        return ArrMethods[property];
-      }
-      return Reflect.get(target, property);
-    },
-    set(target, property, newVal, receiver) {
-      const strProp = property;
-      const oldVal = Reflect.get(target, property);
-      const preventTrigger = isLazySet(strProp);
-      const needKeepVal = needKeep(strProp);
-      const canSet = canSetNewVal({
-        target,
-        property: strProp,
-        newVal,
-        oldVal
-      });
-      if (!canSet) return true;
-      const proxyTarget = receiver || state;
-      newVal = getNewVal({
-        target: proxyTarget,
-        property: strProp,
-        newVal,
-        needKeepVal
-      });
-      Reflect.set(target, property, newVal, receiver);
-      if (preventTrigger) return true;
-      const payload = genPayload({
-        target: proxyTarget,
-        property: strProp,
-        newVal,
-        oldVal
-      });
-      trigger(payload);
-      return true;
-    },
-    deleteProperty(target, property) {
-      const strProp = property;
-      if (!hasOwnProperty(target, strProp)) return true;
-      const oldVal = Reflect.get(target, property);
-      Reflect.deleteProperty(target, property);
-      const payload = genPayload({
-        target: state,
-        property: strProp,
-        newVal: null,
-        oldVal
-      });
-      trigger(payload);
-      return true;
-    }
-  };
-  const state = new Proxy(data, handler);
-  ProxyCache.set(initialData, state);
-  setStateConfig(state, mergedConfig);
-  lazySet(state, initialData);
-  return state;
-}
-var curLazySetKey = null;
-function lazySet(target, data) {
-  if (isObject(data)) {
-    Reflect.ownKeys(data).forEach((key) => {
-      const strKey = key;
-      if (curLazySetKey) throw new Error("[lark-store] lazy set key conflict");
-      curLazySetKey = strKey;
-      target[strKey] = data[strKey];
-    });
-  }
+  return [getState(), setState];
 }
-function isLazySet(property) {
-  if (curLazySetKey === property) {
-    curLazySetKey = "";
-    return true;
-  }
-  return false;
+
+// src/store.ts
+var COMPUTED_BRAND = /* @__PURE__ */ Symbol("lark-store-computed");
+function isComputedMarker(val) {
+  return val !== null && typeof val === "object" && val[COMPUTED_BRAND] === true;
 }
-function shallowSet(target, key, data) {
-  if (!isState(target))
-    throw new Error("[lark-store] shallowSet only supports state objects");
-  if (!isObject(data)) return target[key] = data;
-  keep(key);
-  const config2 = getStateConfig(target);
-  const linkKeys = createLinkKeys(target, key);
-  target[key] = createState(data, {
-    ...config2,
-    linkKeys,
-    shallow: true
-  });
+function computed(deps, fn) {
+  return { [COMPUTED_BRAND]: true, deps, fn };
 }
-var GlobalDeps = /* @__PURE__ */ new Map();
-function track(payload) {
-  const { belong, trackList = [] } = payload;
-  let deps = GlobalDeps.get(belong);
-  if (!deps) GlobalDeps.set(belong, deps = /* @__PURE__ */ new Map());
-  for (const { key, cb } of trackList) {
-    if (isFunction(cb)) {
-      let callbacks = deps.get(key);
-      if (!callbacks) deps.set(key, callbacks = /* @__PURE__ */ new Set());
-      callbacks.add(cb);
-    }
-  }
-}
-function trigger(payload) {
-  const { belong, keys: keys2 } = payload;
-  const store = getStore(belong);
-  if (store && store.status !== 2 /* ACTIVE */ && belong !== LARK_GLOBAL)
-    return;
-  const deps = GlobalDeps.get(belong);
-  if (!deps) return;
-  const tasks = /* @__PURE__ */ new Set();
-  for (const key of keys2) {
-    const callbacks = deps.get(key);
-    if (callbacks) {
-      for (const cb of callbacks) {
-        tasks.add({ cb, params: { [key]: true } });
-      }
-    }
-  }
-  if (tasks.size === 0) return;
-  const scheduler = store?.scheduler;
-  run(Array.from(tasks), scheduler);
-}
-function clear(payload) {
-  if (!payload) {
-    GlobalDeps.clear();
-    return;
-  }
-  const { belong, clearList } = payload;
-  const deps = GlobalDeps.get(belong);
-  if (!deps) return;
-  const store = getStore(belong);
-  const scheduler = store?.scheduler;
-  if (clearList) {
-    for (const { key, cb } of clearList) {
-      const callbacks = deps.get(key);
-      if (callbacks) {
-        if (!cb) {
-          deps.delete(key);
-        } else if (callbacks.has(cb)) {
-          callbacks.delete(cb);
-          if (scheduler && !isFunction(scheduler)) {
-            scheduler.delete([{ cb }]);
-          }
-          if (callbacks.size === 0) deps.delete(key);
+var storeRegistry = /* @__PURE__ */ new Map();
+function create(name, creator) {
+  const listeners = /* @__PURE__ */ new Set();
+  const computedDefs = /* @__PURE__ */ new Map();
+  const computedKeys = /* @__PURE__ */ new Set();
+  const actionKeys = /* @__PURE__ */ new Set();
+  let state;
+  let destroyed = false;
+  const getState = () => state;
+  const setState = (partial) => {
+    if (destroyed) return;
+    const prevState = state;
+    const resolved = typeof partial === "function" ? partial(prevState) : partial;
+    const nextState = { ...prevState };
+    let changed = false;
+    for (const key in resolved) {
+      if (Object.prototype.hasOwnProperty.call(resolved, key) && !computedKeys.has(key) && !actionKeys.has(key)) {
+        const newVal = resolved[key];
+        if (!Object.is(prevState[key], newVal)) {
+          nextState[key] = newVal;
+          changed = true;
         }
       }
     }
-  } else {
-    deps.clear();
-    GlobalDeps.delete(belong);
-    if (scheduler && !isFunction(scheduler)) {
-      scheduler.clear();
-    }
-  }
-}
-var _storeName = /* @__PURE__ */ Symbol("store-name");
-var _storeStatus = /* @__PURE__ */ Symbol("store-status");
-var _storeScheduler = /* @__PURE__ */ Symbol("store-scheduler");
-var _storeCreate = /* @__PURE__ */ Symbol("fn:store-create");
-var _storeBoot = /* @__PURE__ */ Symbol("fn:store-boot");
-var _storeDestroy = /* @__PURE__ */ Symbol("fn:store-destroy");
-var _innerStore = /* @__PURE__ */ Symbol("inner-store");
-var _outerStore = /* @__PURE__ */ Symbol("outer-store");
-var _originState = /* @__PURE__ */ Symbol("origin-state");
-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 BaseStore = class {
-  [_storeStatus] = 0 /* BEFORE_CREATE */;
-  [_storeDefScheduler] = getDefScheduler;
-  [_storeBoot]() {
-    this[_storeStatus] = 2 /* ACTIVE */;
-    return this[_storeProxy](true);
-  }
-  [_storeDestroy]() {
-    clear({ belong: this[_storeName] });
-    this[_storeState] = createState(this[_originState], {
-      belong: this[_storeName]
-    });
-    this[_storeStatus] = 3 /* DESTROYED */;
-  }
-  /**
-   *
-   * @param body - The object returned by the creator function
-   * @param excludeFns - Function keys to exclude from handlers (e.g. ['observe'])
-   */
-  [_storeCreate](body, excludeFns = ["observe"]) {
-    this[_storeStatus] = 1 /* CREATED */;
-    if (isObject(body)) {
-      const state = {};
-      const handlers = {};
-      Reflect.ownKeys(body).forEach((key) => {
-        const strKey = key;
-        const val = body[strKey];
-        if (isFunction(val)) {
-          if (!excludeFns.includes(strKey)) handlers[strKey] = val;
-        } else {
-          state[strKey] = val;
-        }
-      });
-      Object.assign(this, handlers);
-      this[_originState] = cloneData(state);
-      this[_stateKeys] = Object.keys(state);
-      this[_storeState] = createState(state, { belong: this[_storeName] });
+    if (!changed) return;
+    state = nextState;
+    recomputeIfNeeded(prevState);
+    for (const listener of listeners) {
+      listener(state, prevState);
     }
-  }
-  constructor(name, config2) {
-    this[_storeName] = name;
-    this[_storeScheduler] = config2?.scheduler || this[_storeDefScheduler]();
-    this[_outerStore] = this[_storeProxy](true);
-  }
-  [_innerStore]() {
-    return this[_storeProxy]();
-  }
-  get status() {
-    return this[_storeStatus];
-  }
-  get storeName() {
-    return this[_storeName];
-  }
-  get scheduler() {
-    return this[_storeScheduler];
-  }
-  [_storeProxy](toOut = false) {
-    const self = this;
-    return new Proxy(self, {
-      get(target, property) {
-        if (self[_stateKeys].includes(property)) {
-          const val = self[_storeState][property];
-          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;
-        }
-        return true;
-      },
-      has(target, property) {
-        return Reflect.has(target, property) || self[_stateKeys].includes(property);
+  };
+  const recomputeIfNeeded = (prevState) => {
+    if (computedDefs.size === 0) return;
+    const changedKeys2 = /* @__PURE__ */ new Set();
+    for (const key of Object.keys(state)) {
+      if (!Object.is(
+        state[key],
+        prevState[key]
+      )) {
+        changedKeys2.add(key);
       }
-    });
-  }
-};
-var LarkUtils = {
-  isLarkView(instance) {
-    return isObject(instance) && !!instance.updater;
-  },
-  getRender(view) {
-    return view.updater.digest.bind(view.updater);
-  },
-  getDataSetter(view) {
-    return view.updater.set.bind(view.updater);
-  },
-  onDestroy(view, cb) {
-    view.on("destroy", cb);
-  }
-};
-var getLarkAdapter = (storeName) => ({
-  Store: LarkStore,
-  useStore: ((view) => {
-    const store = getStore(storeName);
-    return store[_storeBoot](view);
-  })
-});
-var innerObserveFlags = /* @__PURE__ */ Symbol("store-inner-observe-flags");
-var boundViews = /* @__PURE__ */ Symbol("bound-views");
-var LarkStore = class extends BaseStore {
-  [boundViews] = /* @__PURE__ */ new Set();
-  [innerObserveFlags] = /* @__PURE__ */ new Set();
-  [_storeBoot](view) {
-    if (view && LarkUtils.isLarkView(view) && !this[boundViews].has(view)) {
-      this[boundViews].add(view);
-      LarkUtils.onDestroy(view, () => {
-        this[boundViews].delete(view);
-      });
     }
-    return super[_storeBoot]();
-  }
-  [_storeDestroy]() {
-    this[boundViews].clear();
-    this[innerObserveFlags].clear();
-    super[_storeDestroy]();
-  }
-  observe(view, keys2, defCallback) {
-    if (this[_storeStatus] !== 2 /* ACTIVE */) return noop;
-    let observeKeys = 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];
-    if (isFunction(keys2)) {
-      const res = keys2();
-      if (Array.isArray(res)) observeKeys = res;
-    }
-    const defSetter = (immediate, key, alias, transform) => () => {
-      const stateVal = getDataByKey(this, key);
-      let data = { [alias || key]: stateVal };
-      if (transform && isFunction(transform)) {
-        const newData = transform(stateVal);
-        if (isObject(newData)) data = newData;
-      }
-      if (immediate) dateSetterFn(data);
-      else renderFn(data);
-    };
-    const getList = (immediate = false) => {
-      const list = [];
-      for (const item of observeKeys) {
-        if (!item) continue;
-        const payload = typeof item === "string" ? { key: item } : item;
-        const { cb: cbDefault = defCallback, key } = payload;
-        let cb = cbDefault;
-        const { alias, lazy = true, transform } = payload;
-        if (!key) continue;
-        const c1 = !immediate;
-        const c2 = !cb && !!_view;
-        const c3 = !!cb && String(lazy) === "false";
-        if (!(c1 || c2 || c3)) continue;
-        if (isInnerObserve && cb) {
-          const flag = `storeInner_${key}_${observeKeys.join("-")}_${cb.toString()}`;
-          if (!storeInnerObserveFlags.has(flag)) {
-            storeInnerObserveFlags.add(flag);
-            innerFlags.add(flag);
-          }
+    let recomputed = false;
+    for (const [key, def] of computedDefs) {
+      if (def.deps.some((dep) => changedKeys2.has(dep))) {
+        const newVal = def.fn();
+        if (!Object.is(state[key], newVal)) {
+          state[key] = newVal;
+          recomputed = true;
         }
-        if (c2) cb = defSetter(immediate, key, alias, transform);
-        if (cb) list.push({ key, cb });
       }
-      return list;
-    };
-    const trackList = getList();
-    track({ belong: this[_storeName], trackList });
-    if (_view) {
-      LarkUtils.onDestroy(
-        _view,
-        () => clear({ belong: this[_storeName], clearList: trackList })
-      );
     }
-    if (!isInnerObserve) run(getList(true));
+    if (recomputed) {
+    }
+  };
+  const subscribe = (listener) => {
+    listeners.add(listener);
     return () => {
-      clear({ belong: this[_storeName], clearList: trackList });
-      innerFlags.forEach((flag) => storeInnerObserveFlags.delete(flag));
+      listeners.delete(listener);
     };
-  }
-};
-var getReactAdapter = (storeName) => ({
-  Store: ReactStore,
-  useStore: (() => {
-    const store = getStore(storeName);
-    return store[_storeBoot]();
-  })
-});
-var observeSym = /* @__PURE__ */ Symbol("observe");
-var getLastState = /* @__PURE__ */ Symbol("get-last-state");
-var ReactStore = class extends BaseStore {
-  stateChangeCount = 0;
-  lastCount = 0;
-  lastState = null;
-  constructor(name, config2) {
-    const effectiveConfig = config2 && !config2.scheduler ? {
-      ...config2,
-      scheduler: (cb, params) => cb(params)
-    } : config2;
-    super(name, effectiveConfig);
-  }
-  [_storeCreate](body) {
-    super[_storeCreate](body);
-    this[observeSym](() => {
-      this.stateChangeCount += 1;
-    });
-  }
-  isStateChanged() {
-    const currCount = this.stateChangeCount;
-    const changed = this.lastCount !== currCount;
-    this.lastCount = currCount;
-    return changed;
-  }
-  [getLastState](handlers) {
-    if (this.isStateChanged() || !this.lastState) {
-      const state = this[_storeState];
-      const immutableState = freezeData(state);
-      this.lastState = Object.assign({}, handlers, immutableState);
-    }
-    return this.lastState;
-  }
-  [observeSym](cb) {
-    const tasks = this[_stateKeys].map((key) => ({ key, cb }));
-    track({ belong: this[_storeName], trackList: tasks });
-    return () => clear({ belong: this[_storeName], clearList: tasks });
-  }
-};
-var freezeData = (target) => {
-  const data = {};
-  const keys2 = Object.keys(target);
-  for (const key of keys2) {
-    const value = target[key];
-    if (Array.isArray(value)) {
-      data[key] = value.map(
-        (item) => isObject(item) ? freezeData(item) : item
-      );
-    } else if (isObject(value)) {
-      data[key] = freezeData(value);
+  };
+  const destroy = () => {
+    destroyed = true;
+    listeners.clear();
+    storeRegistry.delete(name);
+  };
+  const api = { getState, setState, subscribe, destroy };
+  const body = creator(setState, getState);
+  const initialState = {};
+  const actions = {};
+  for (const key of Object.keys(body)) {
+    const val = body[key];
+    if (isComputedMarker(val)) {
+      computedDefs.set(key, val);
+      computedKeys.add(key);
+      initialState[key] = void 0;
+    } else if (typeof val === "function") {
+      actions[key] = val;
+      actionKeys.add(key);
     } else {
-      data[key] = value;
+      initialState[key] = val;
     }
   }
-  return data;
-};
-var getNodeAdapter = (storeName) => ({
-  Store: NodeStore,
-  useStore: (() => {
-    const store = getStore(storeName);
-    return store[_storeBoot]();
-  })
-});
-var NodeStore = class extends BaseStore {
-  observe(key, callback, immediate = true) {
-    const tasks = [{ key, cb: callback }];
-    track({ belong: this[_storeName], trackList: tasks });
-    if (immediate) run(tasks);
-    return () => clear({ belong: this[_storeName], clearList: tasks });
-  }
-};
-var getAdapter = (platform, storeName) => {
-  switch (platform) {
-    case "react" /* React */:
-      return getReactAdapter(storeName);
-    case "node" /* Node */:
-      return getNodeAdapter(storeName);
-    case "lark" /* Lark */:
-    default:
-      return getLarkAdapter(storeName);
-  }
-};
-var getPlatform = (comp) => {
-  if (LarkUtils.isLarkView(comp)) return "lark" /* Lark */;
-  return void 0;
-};
-var extendApis = { lazySet, shallowSet };
-var StoreCache = /* @__PURE__ */ new Map();
-function defineStore(name, creator, config2) {
-  if (StoreCache.has(name)) {
-    name = name + "_copy";
-  }
-  const { platform = "lark" /* Lark */ } = config2 || {};
-  const adapter = getAdapter(platform, name);
-  const StoreClass = adapter.Store;
-  const useStore = adapter.useStore;
-  const store = new StoreClass(name, config2);
-  store[_storeCreate](
-    creator(store[_innerStore](), extendApis)
-  );
-  Object.defineProperties(useStore, {
-    $storeName: { value: name, configurable: true },
-    $destroyFn: { value: () => store[_storeDestroy](), configurable: true }
-  });
-  if (!StoreCache.has(name)) {
-    StoreCache.set(name, { store, creator, config: config2, useStore });
-  }
-  return useStore;
-}
-function getStore(name) {
-  if (name && StoreCache.has(name)) {
-    const entry = StoreCache.get(name);
-    return entry ? entry.store : void 0;
-  }
-  return void 0;
-}
-function delStore(name) {
-  if (name && StoreCache.has(name)) StoreCache.delete(name);
-}
-function getUseStore(name) {
-  if (name && StoreCache.has(name)) {
-    const entry = StoreCache.get(name);
-    return entry ? entry.useStore : void 0;
+  state = { ...initialState, ...actions };
+  for (const [key, def] of computedDefs) {
+    state[key] = def.fn();
   }
-  return void 0;
-}
-function cloneStore(name, useStore, config2) {
-  const oldStoreName = useStore["$storeName"];
-  const cached = StoreCache.get(oldStoreName);
-  const oldStoreCreator = cached?.creator;
-  const oldConfig = cached?.config || {};
-  if (!name || !oldStoreCreator) return;
-  const mergedConfig = { ...oldConfig, ...config2 || {} };
-  return defineStore(
-    name,
-    oldStoreCreator,
-    mergedConfig
-  );
+  storeRegistry.set(name, api);
+  return api;
 }
-function isStoreActive(name) {
-  if (name && StoreCache.has(name)) {
-    const entry = StoreCache.get(name);
-    return entry ? entry.store.status === 2 /* ACTIVE */ : false;
-  }
-  return false;
-}
-var cellCount = 0;
-function cell(data) {
-  return createState(data, {
-    belong: LARK_GLOBAL,
-    linkKeys: `${LARK_GLOBAL}_${cellCount++}`
-  });
-}
-function observeCell(state, cb, immediate = true) {
-  const linkKeys = getLinkKeys(state);
-  if (!linkKeys)
-    return () => {
-    };
-  const keys2 = linkKeys.split(".");
-  const key = keys2[keys2.length - 1];
-  const list = [{ key, cb }];
-  track({ belong: LARK_GLOBAL, trackList: list });
-  if (immediate) cb();
-  return () => clear({ belong: LARK_GLOBAL, clearList: list });
+function isLarkView(instance) {
+  if (!instance || typeof instance !== "object") return false;
+  const obj = instance;
+  const updater = obj["updater"];
+  return updater !== null && typeof updater === "object" && typeof updater["set"] === "function" && typeof updater["digest"] === "function";
 }
-function multi(useStore) {
-  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"] || "";
-    let flag;
-    if (viewPath === rootViewPath) {
-      flag = `${flagSym}-${viewId}`;
-    } else {
-      flag = owner?.["viewInitParams"]?.[flagSym];
-    }
-    if (owner && isFunction(owner["mountFrame"])) {
-      const rawMountFrame = owner["mountFrame"];
-      owner["mountFrame"] = (vfId, viewPath2, viewInitParams = {}) => rawMountFrame.call(
-        owner,
-        vfId,
-        viewPath2,
-        Object.assign(viewInitParams, { [flagSym]: flag })
-      );
-    }
-    return flag;
+function bindStore(view, store, selector) {
+  if (!isLarkView(view)) return () => {
   };
-  const useFn = ((view) => {
-    if (!view)
-      throw new Error(
-        "[@lark.js/mvc error] multi: cannot find the view instance"
-      );
-    const viewCtx = view;
-    const flag = viewCtx[flagSym];
-    if (map.has(flag)) return map.get(flag);
-    const newFn = cloneStore(flag, useStore);
-    map.set(flag, newFn);
-    return useFn(view);
-  });
-  const mixinObj = {
-    make() {
-      if (!rootViewPath) {
-        const owner = this["owner"];
-        rootViewPath = owner?.["path"] || "";
+  const extract = (s) => {
+    if (selector) return selector(s);
+    const result = {};
+    for (const key in s) {
+      if (Object.prototype.hasOwnProperty.call(s, key) && typeof s[key] !== "function") {
+        result[key] = s[key];
       }
-      this[flagSym] = getFlag(this);
     }
+    return result;
   };
-  return [useFn, mixinObj];
+  view.updater.set(extract(store.getState()));
+  view.updater.digest();
+  const off = store.subscribe((state) => {
+    view.updater.set(extract(state));
+    view.updater.digest();
+  });
+  view.on("destroy", off);
+  return off;
 }
+var defineStore = create;
 
 // src/compiler.ts
 var import_parser = require("@babel/parser");
-var SPLITTER2 = "";
-var VIEW_ID_PLACEHOLDER = "";
+var SPLITTER2 = String.fromCharCode(30);
+var VIEW_ID_PLACEHOLDER = String.fromCharCode(31);
 function jsObjectToUrlParams(paramsStr) {
   const trimmed = paramsStr.trim();
   if (!/^[{[]/.test(trimmed) && /=/.test(trimmed)) {
@@ -4618,7 +4389,7 @@ function addLineMarkers(source) {
     if (parts.length > 1) {
       const reconstructed = parts.map((part, i) => {
         if (i === 0) return part;
-        return openTag + SPLITTER2 + ++lineNo;
+        return openTag + SPLITTER2 + ++lineNo + part;
       }).join("");
       result.push(reconstructed);
     } else {
@@ -4754,7 +4525,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 });
@@ -4978,13 +4749,9 @@ function compileToFunction(source, debug, file) {
   }
   const viewIdRegExp = new RegExp(String.fromCharCode(31), "g");
   funcSource = funcSource.replace(viewIdRegExp, `'+$viewId+'`);
-  const atRule = hasAtRule ? `if(!$refFn){$refFn=(ref,v,k,f)=>{for(f=ref[$splitter];--f;)if(ref[k=$splitter+f]===v)return k;ref[k=$splitter+ref[$splitter]++]=v;return k;}}` : "";
-  const encode = `if(!$strSafe){let $entMap={'&':'amp','<':'lt','>':'gt','"':'#34','\\'':'#39','\`':'#96'},$entReg=/[&<>"'\`]/g,$entFn=m=>'&'+$entMap[m]+';';$strSafe=v=>''+(v==null?'':v);$encHtml=v=>$strSafe(v).replace($entReg,$entFn)}`;
-  const encodeURIMore = `if(!$encUri){let $uriMap={'!':'%21','\\'':'%27','(':'%28',')':'%29','*':'%2A'},$uriFn=m=>$uriMap[m],$uriReg=/[!')(*]/g;$encUri=v=>encodeURIComponent($strSafe(v)).replace($uriReg,$uriFn)}`;
-  const encodeQuote = `if(!$encQuote){let $qReg=/['"\\\\]/g;$encQuote=v=>$strSafe(v).replace($qReg,'\\\\$&')}`;
+  void hasAtRule;
   const refFallback = "if(!$refAlt)$refAlt=$data;";
-  const fns = `${refFallback}${encode}${encodeURIMore}${encodeQuote}${atRule};`;
-  const fullSource = `${fns}let $splitter='\\x1e',$tmp,$out=''{{VARS}};${funcSource}return $out`;
+  const fullSource = `${refFallback}let $splitter='\\x1e',$tmp,$out=''{{VARS}};${funcSource}return $out`;
   return `($data,$viewId,$refAlt,$encHtml,$strSafe,$encUri,$refFn,$encQuote)=>{${fullSource}}`;
 }
 function compileTemplate(source, options = {}) {
@@ -4996,15 +4763,12 @@ function compileTemplate(source, options = {}) {
   const funcBody = compileToFunction(finalSource, debug, file);
   const varDeclarations = globalVars.map((key) => `,${key}=$data.${key}`).join("");
   const funcWithVars = funcBody.replace("{{VARS}}", () => varDeclarations);
-  return `export default function(data, selfId, refData) {
+  return `import { encHtml as __larkEncHtml, strSafe as __larkStrSafe, encUri as __larkEncUri, encQuote as __larkEncQuote, refFn as __larkRefFn } from "@lark.js/mvc/runtime";
+export default function(data, viewId, refData) {
   let $data = data || {},
-      $viewId = selfId || '';
+      $viewId = viewId || '';
   return (${funcWithVars})($data, $viewId, refData,
-    /* $encHtml */ v => String(v == null ? '' : v).replace(/[&<>"'\`]/g, m => '&' + ({'&':'amp','<':'lt','>':'gt','"':'#34',"'":'#39','\`':'#96'})[m] + ';'),
-    /* $strSafe */ v => String(v == null ? '' : v),
-    /* $encUri */ null,
-    /* $refFn */ null,
-    /* $encQuote */ null
+    __larkEncHtml, __larkStrSafe, __larkEncUri, __larkRefFn, __larkEncQuote
   );
 }`;
 }
@@ -5018,7 +4782,7 @@ function extractGlobalVars(source) {
   const htmlStore = {};
   let htmlIndex = 0;
   let lastIndex = 0;
-  const htmlKey = "";
+  const htmlKey = String.fromCharCode(5);
   template.replace(
     templateCmdRegExp,
     (match, operate, content, offset) => {
@@ -5129,31 +4893,37 @@ function walkAst(ast, visitors) {
     if (visitors[type]) {
       visitors[type](node);
     }
+    const bag = node;
     for (const key of Object.keys(node)) {
       if (key === "type" || key === "start" || key === "end" || key === "loc" || key === "range")
         continue;
-      if (type === "MemberExpression" && key === "property" && !node.computed)
-        continue;
-      if (type === "ObjectProperty" && key === "key" && !node.computed) {
-        continue;
+      if (type === "MemberExpression" && key === "property") {
+        const me = node;
+        if (!me.computed) continue;
       }
-      if (type === "ObjectMethod" && key === "key" && !node.computed) {
-        continue;
+      if (type === "ObjectProperty" && key === "key") {
+        const op = node;
+        if (!op.computed) continue;
+      }
+      if (type === "ObjectMethod" && key === "key") {
+        const om = node;
+        if (!om.computed) continue;
       }
-      const child = node[key];
+      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) ───────
   //
@@ -5308,14 +5078,15 @@ var BUILTIN_GLOBAL_SET = new Set(Object.keys(BUILTIN_GLOBALS));
 0 && (module.exports = {
   CALL_BREAK_TIME,
   Cache,
+  CrossSite,
   EVENT_METHOD_REGEXP,
   EventDelegator,
   EventEmitter,
   Frame,
+  FrameVisualBridge,
   Framework,
   LARK_VIEW,
   Payload,
-  Platform,
   ROUTER_EVENTS,
   Router,
   SPLITTER,
@@ -5329,59 +5100,52 @@ var BUILTIN_GLOBAL_SET = new Set(Object.keys(BUILTIN_GLOBALS));
   applyStyle,
   applyVdomOps,
   assign,
-  cell,
-  classExtend,
-  cloneData,
-  cloneStore,
+  bindStore,
   compileTemplate,
-  createState,
+  computed,
+  create,
   createVdomRef,
   defineStore,
-  delStore,
+  defineView,
   encodeHTML,
   encodeQ,
   encodeSafe,
   encodeURIExtra,
   ensureElementId,
   extractGlobalVars,
+  frameworkConfig,
   funcWithTry,
   generateId,
   getAttribute,
   getById,
-  getPlatform,
-  getStore,
-  getUseStore,
-  has,
+  getRouteMode,
+  hasOwnProperty,
   installFrameVisualizerBridge,
+  invalidateViewClass,
   isPlainObject,
   isPrimitive,
   isPrimitiveOrFunc,
-  isState,
-  isStoreActive,
   keys,
-  lazySet,
   mark,
   markBooted,
   markRouterBooted,
-  multi,
   nextCounter,
   nodeInside,
   noop,
   now,
-  observeCell,
   parseUri,
   registerViewClass,
+  resetProjectsMap,
   safeguard,
   serializeFrameTree,
   setData,
-  shallowSet,
-  storeMark,
-  storeUnmark,
   syncCounter,
   toMap,
   toUri,
   translateData,
   unmark,
+  use,
+  useUrlState,
   vdomGetCompareKey,
   vdomGetNode,
   vdomSetAttributes,