@lark.js/mvc 0.0.11 → 0.0.13

package/dist/index.cjs

@@ -53,8 +53,8 @@ __export(index_exports, {
   markRouterBooted: () => markRouterBooted,
   nextCounter: () => nextCounter,
   registerViewClass: () => registerViewClass,
+  reloadViews: () => reloadViews,
   resetProjectsMap: () => resetProjectsMap,
-  safeguard: () => safeguard,
   unmark: () => unmark,
   use: () => use,
   useUrlState: () => useUrlState,
@@ -85,7 +85,6 @@ var MATH_NS = "http://www.w3.org/1998/Math/MathML";
 var TAG_NAME_REGEXP = /<([a-z][^/\0>\x20\t\r\n\f]+)/i;
 var CALL_BREAK_TIME = 48;
 var V_TEXT_NODE = 0;
-var TAG_STATIC_KEY = "_";
 var VDOM_NS_MAP = {
   svg: SVG_NS,
   math: MATH_NS
@@ -431,61 +430,6 @@ function unmark(host) {
   }
 }
 
-// src/safeguard.ts
-var proxiesPool = /* @__PURE__ */ new Map();
-var SAFEGUARD_SENTINEL = "_safe_";
-function safeguard(data, getter, setter, isRoot) {
-  if (typeof window.__lark_Debug === "undefined" || !window.__lark_Debug) {
-    return data;
-  }
-  if (typeof Proxy === "undefined") {
-    return data;
-  }
-  if (isPrimitive(data)) {
-    return data;
-  }
-  const build = (prefix, obj) => {
-    const cacheKey = (getter || "") + "
" + (setter || "");
-    const cached = proxiesPool.get(obj);
-    if (cached && cached.cacheKey === cacheKey) {
-      return cached.entity;
-    }
-    if (Reflect.get(obj, SAFEGUARD_SENTINEL)) {
-      return obj;
-    }
-    const entity = new Proxy(obj, {
-      set(target, property, value) {
-        if (!setter && !prefix) {
-          throw new Error(
-            "Avoid write back, key: " + prefix + property + " value:" + value + " more: https://github.com/hangtiancheng/lark"
-          );
-        }
-        Reflect.set(target, property, value);
-        if (setter) {
-          setter(prefix + property, value);
-        }
-        return true;
-      },
-      get(target, property) {
-        if (property === SAFEGUARD_SENTINEL) {
-          return true;
-        }
-        const out = Reflect.get(target, property);
-        if (!prefix && getter) {
-          getter(property);
-        }
-        if (!isRoot && hasOwnProperty(target, property) && (Array.isArray(out) || isPlainObject(out))) {
-          return build(prefix + property + ".", out);
-        }
-        return out;
-      }
-    });
-    proxiesPool.set(obj, { cacheKey, entity });
-    return entity;
-  };
-  return build("", data);
-}
-
 // src/cache.ts
 function sortCacheEntries(a, b) {
   return b.frequency - a.frequency || b.lastTimestamp - a.lastTimestamp;
@@ -761,7 +705,6 @@ var keyRefCounts = {};
 var changedKeys = /* @__PURE__ */ new Set();
 var stashedChangedKeys = EMPTY_STRING_SET;
 var dataIsChanged = false;
-var dataWhereSet = {};
 var emitter = new EventEmitter();
 var booted = false;
 function markBooted() {
@@ -785,47 +728,16 @@ function teardownKeysRef(keyList) {
       if (count <= 0) {
         Reflect.deleteProperty(keyRefCounts, key);
         Reflect.deleteProperty(appData, key);
-        if (typeof window.__lark_Debug !== "undefined" && window.__lark_Debug) {
-          Reflect.deleteProperty(dataWhereSet, key);
-        }
       }
     }
   }
 }
-var warnedKeys = /* @__PURE__ */ new Set();
-function clearNotify(key) {
-  warnedKeys.delete(key);
-}
-function delayNotify(key, message) {
-  if (warnedKeys.has(key)) return;
-  warnedKeys.add(key);
-  console.warn(message);
-}
 var State = {
   /**
    * Get data from state.
    */
   get(key) {
     const result = key ? appData[key] : appData;
-    if (typeof window.__lark_Debug !== "undefined" && window.__lark_Debug) {
-      return safeguard(
-        result,
-        (dataKey) => {
-          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]}`
-            );
-          }
-        },
-        (path, _value) => {
-          const sub = key || path;
-          delayNotify(
-            sub,
-            `beware! You direct modify "{State}.${sub}" You should call State.set() and State.digest() to notify other views`
-          );
-        }
-      );
-    }
     return result;
   },
   /**
@@ -833,11 +745,6 @@ var State = {
    */
   set(data, excludes) {
     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;
-      }
-    }
     return State;
   },
   /**
@@ -848,11 +755,6 @@ var State = {
       State.set(data, excludes);
     }
     if (dataIsChanged) {
-      if (typeof window.__lark_Debug !== "undefined" && window.__lark_Debug) {
-        for (const p of changedKeys) {
-          clearNotify(p);
-        }
-      }
       dataIsChanged = false;
       const keys2 = changedKeys;
       stashedChangedKeys = keys2;
@@ -1094,9 +996,6 @@ var Router = {
       attachViewAndPath(location);
       hrefCache.set(href, location);
     }
-    if (typeof window.__lark_Debug !== "undefined" && window.__lark_Debug) {
-      location["params"] = safeguard(location["params"]);
-    }
     return location;
   },
   /**
@@ -1115,9 +1014,6 @@ var Router = {
       emitter2.fire(RouterEvents.CHANGED, asRecord(lastChanged));
     }
     silent = 0;
-    if (typeof window.__lark_Debug !== "undefined" && window.__lark_Debug && lastChanged) {
-      lastChanged = safeguard(lastChanged);
-    }
     return lastChanged;
   },
   /**
@@ -1874,6 +1770,13 @@ function vdomCreate(tag, props, children, specials) {
         reused[c.compareKey] = (reused[c.compareKey] || 0) + 1;
         reusedTotal++;
       }
+      if (c.reused) {
+        if (!reused) reused = {};
+        for (const key in c.reused) {
+          reused[key] = (reused[key] || 0) + c.reused[key];
+          reusedTotal += c.reused[key];
+        }
+      }
       if (c.views) {
         if (!viewList) viewList = [];
         viewList.push(...c.views);
@@ -1891,7 +1794,7 @@ function vdomCreate(tag, props, children, specials) {
     } else if (value === true) {
       propsObj[prop] = value = specialsObj[prop] ? value : "";
     }
-    if ((prop === "#" || prop === "id" || prop === TAG_STATIC_KEY) && !compareKey) {
+    if ((prop === "#" || prop === "id") && !compareKey) {
       compareKey = value;
       if (prop !== "id") {
         delete propsObj[prop];
@@ -1938,18 +1841,6 @@ function vdomCreate(tag, props, children, specials) {
 function isSameVDomNode(a, b) {
   return a.compareKey && b.compareKey === a.compareKey || !a.compareKey && !b.compareKey && a.tag === b.tag || a.tag === SPLITTER || b.tag === SPLITTER;
 }
-function getKeyNodes(list, nodes, start, end, realEnd) {
-  const keyedNodes = {};
-  for (let i = end, re = realEnd; i >= start; i--, re--) {
-    const oc = list[i];
-    const cKey = oc.compareKey;
-    if (cKey) {
-      const bucket = keyedNodes[cKey] || (keyedNodes[cKey] = []);
-      bucket.push(nodes[re]);
-    }
-  }
-  return keyedNodes;
-}
 function vdomCreateNode(vnode, owner, ref) {
   const tag = vnode.tag;
   if (tag === V_TEXT_NODE) {
@@ -2038,9 +1929,10 @@ function vdomSetNode(realNode, oldParent, lastVDom, newVDom, ref, frame, keys2,
     return;
   }
   if (lastTag === newTag) {
-    const lastAMap = lastVDom.attrsMap || {};
-    const newAMap = newVDom.attrsMap || {};
-    if (lastVDom.compareKey && lastVDom.compareKey === newVDom.compareKey && !lastAMap["id"] && !newAMap["id"]) {
+    if (lastVDom.attrs === newVDom.attrs && lastVDom.html === newVDom.html) {
+      if (newVDom.hasSpecials) {
+        vdomSyncFormState(realNode, newVDom);
+      }
       return;
     }
     let attrChanged = 0;
@@ -2081,261 +1973,209 @@ function vdomSetNode(realNode, oldParent, lastVDom, newVDom, ref, frame, keys2,
     oldParent.replaceChild(vdomCreateNode(newVDom, oldParent, ref), realNode);
   }
 }
+function computeLIS(sequence) {
+  const len = sequence.length;
+  if (len === 0) return [];
+  const result = [];
+  const tails = [];
+  const predecessors = new Array(len);
+  let lisLength = 0;
+  for (let i = 0; i < len; i++) {
+    const value = sequence[i];
+    if (value < 0) continue;
+    let lo = 0;
+    let hi = lisLength;
+    while (lo < hi) {
+      const mid = lo + hi >>> 1;
+      if (sequence[tails[mid]] < value) lo = mid + 1;
+      else hi = mid;
+    }
+    tails[lo] = i;
+    predecessors[i] = lo > 0 ? tails[lo - 1] : -1;
+    if (lo === lisLength) lisLength++;
+  }
+  let cursor = tails[lisLength - 1];
+  for (let i = lisLength - 1; i >= 0; i--) {
+    result[i] = cursor;
+    cursor = predecessors[cursor];
+  }
+  return result;
+}
 function vdomSetChildNodes(realNode, lastVDom, newVDom, ref, frame, keys2, view, ready) {
   if (!lastVDom) {
     ref.changed = 1;
     realNode.innerHTML = newVDom.html;
+    callFunction(ready, []);
     return;
   }
   if (lastVDom.html === newVDom.html) {
+    callFunction(ready, []);
     return;
   }
   const oldChildren = lastVDom.children;
   const newChildren = newVDom.children;
   const oldLen = oldChildren?.length || 0;
   const newLen = newChildren?.length || 0;
-  if (oldLen === 0 && newLen === 0) return;
+  if (oldLen === 0 && newLen === 0) {
+    callFunction(ready, []);
+    return;
+  }
   const nodes = realNode.childNodes;
-  let oldStart = 0;
-  let oldEnd = oldLen - 1;
-  let newStart = 0;
-  let newEnd = newLen - 1;
-  let realStart = oldStart;
-  let realEnd = oldEnd;
-  let keyedNodes;
-  const oldReusedTotal = lastVDom.reusedTotal || 0;
-  const newReusedTotal = newVDom.reusedTotal || 0;
-  let oldStartNode = oldChildren?.[oldStart];
-  let oldEndNode = oldChildren?.[oldEnd];
-  let newStartNode = newChildren?.[newStart];
-  let newEndNode = newChildren?.[newEnd];
-  while (oldStart <= oldEnd && newStart <= newEnd) {
-    if (!oldStartNode) {
-      oldStartNode = oldChildren?.[++oldStart];
-      realStart++;
-      continue;
-    }
-    if (!oldEndNode) {
-      oldEndNode = oldChildren?.[--oldEnd];
-      realEnd--;
-      continue;
-    }
-    if (isSameVDomNode(newStartNode, oldStartNode)) {
-      if (newStartNode.tag === SPLITTER || oldStartNode.tag === SPLITTER) {
-        ref.changed = 1;
-        domUnmountFrames(frame, realNode);
-        if (newStartNode.tag === SPLITTER) {
-          realNode.innerHTML = newStartNode.html;
-        } else {
-          realNode.innerHTML = "";
-          realNode.appendChild(vdomCreateNode(newStartNode, realNode, ref));
-        }
-      } else {
-        vdomSetNode(
-          nodes[realStart],
-          realNode,
-          oldStartNode,
-          newStartNode,
-          ref,
-          frame,
-          keys2,
-          view,
-          ready
-        );
-      }
-      reduceCached(keyedNodes, oldStartNode, nodes[realStart]);
-      realStart++;
-      oldStartNode = oldChildren?.[++oldStart];
-      newStartNode = newChildren?.[++newStart];
-    } else if (isSameVDomNode(newEndNode, oldEndNode)) {
-      if (newEndNode.tag === SPLITTER || oldEndNode.tag === SPLITTER) {
-        ref.changed = 1;
-        domUnmountFrames(frame, realNode);
-        realNode.innerHTML = newEndNode.tag === SPLITTER ? newEndNode.html : "";
-        if (newEndNode.tag !== SPLITTER) {
-          realNode.appendChild(vdomCreateNode(newEndNode, realNode, ref));
-        }
-      } else {
-        vdomSetNode(
-          nodes[realEnd],
-          realNode,
-          oldEndNode,
-          newEndNode,
-          ref,
-          frame,
-          keys2,
-          view,
-          ready
-        );
-      }
-      reduceCached(keyedNodes, oldEndNode, nodes[realEnd]);
-      realEnd--;
-      oldEndNode = oldChildren?.[--oldEnd];
-      newEndNode = newChildren?.[--newEnd];
-    } else if (isSameVDomNode(newEndNode, oldStartNode)) {
-      if (newEndNode.tag === SPLITTER || oldStartNode.tag === SPLITTER) {
-        ref.changed = 1;
-        domUnmountFrames(frame, realNode);
-        realNode.innerHTML = newEndNode.tag === SPLITTER ? newEndNode.html : "";
-        if (newEndNode.tag !== SPLITTER) {
-          realNode.appendChild(vdomCreateNode(newEndNode, realNode, ref));
-        }
-      } else {
-        const oi = nodes[realStart];
-        realNode.insertBefore(oi, nodes[realEnd + 1] || null);
-        vdomSetNode(
-          oi,
-          realNode,
-          oldStartNode,
-          newEndNode,
-          ref,
-          frame,
-          keys2,
-          view,
-          ready
-        );
-      }
-      reduceCached(keyedNodes, oldStartNode, nodes[realStart]);
-      realStart++;
-      oldStartNode = oldChildren?.[++oldStart];
-      newEndNode = newChildren?.[--newEnd];
-    } else if (isSameVDomNode(newStartNode, oldEndNode)) {
-      if (newStartNode.tag === SPLITTER || oldEndNode.tag === SPLITTER) {
-        ref.changed = 1;
-        domUnmountFrames(frame, realNode);
-        realNode.innerHTML = newStartNode.tag === SPLITTER ? newStartNode.html : "";
-        if (newStartNode.tag !== SPLITTER) {
-          realNode.appendChild(vdomCreateNode(newStartNode, realNode, ref));
-        }
-      } else {
-        const oi = nodes[realEnd];
-        realNode.insertBefore(oi, nodes[realStart]);
-        vdomSetNode(
-          oi,
-          realNode,
-          oldEndNode,
-          newStartNode,
-          ref,
-          frame,
-          keys2,
-          view,
-          ready
-        );
-      }
-      reduceCached(keyedNodes, oldEndNode, nodes[realEnd]);
-      realEnd--;
-      oldEndNode = oldChildren?.[--oldEnd];
-      newStartNode = newChildren?.[++newStart];
+  const oldDomNodes = new Array(oldLen);
+  for (let i = 0; i < oldLen; i++) {
+    oldDomNodes[i] = nodes[i];
+  }
+  const usedOldDomNodes = /* @__PURE__ */ new Set();
+  let headIdx = 0;
+  let tailIdx = oldLen - 1;
+  let newHead = 0;
+  let newTail = newLen - 1;
+  while (headIdx <= tailIdx && newHead <= newTail) {
+    const oc = oldChildren[headIdx];
+    const nc = newChildren[newHead];
+    if (!isSameVDomNode(nc, oc)) break;
+    if (nc.tag === SPLITTER || oc.tag === SPLITTER) break;
+    vdomSetNode(
+      oldDomNodes[headIdx],
+      realNode,
+      oc,
+      nc,
+      ref,
+      frame,
+      keys2,
+      view,
+      ready
+    );
+    usedOldDomNodes.add(oldDomNodes[headIdx]);
+    headIdx++;
+    newHead++;
+  }
+  while (headIdx <= tailIdx && newHead <= newTail) {
+    const oc = oldChildren[tailIdx];
+    const nc = newChildren[newTail];
+    if (!isSameVDomNode(nc, oc)) break;
+    if (nc.tag === SPLITTER || oc.tag === SPLITTER) break;
+    vdomSetNode(
+      oldDomNodes[tailIdx],
+      realNode,
+      oc,
+      nc,
+      ref,
+      frame,
+      keys2,
+      view,
+      ready
+    );
+    usedOldDomNodes.add(oldDomNodes[tailIdx]);
+    tailIdx--;
+    newTail--;
+  }
+  if (headIdx > tailIdx && newHead > newTail) {
+    if (ref.asyncCount === 0) callFunction(ready, []);
+    return;
+  }
+  const keyMap = {};
+  for (let i = headIdx; i <= tailIdx; i++) {
+    const c = oldChildren[i];
+    if (c?.compareKey) {
+      if (!keyMap[c.compareKey]) keyMap[c.compareKey] = [];
+      keyMap[c.compareKey].push({ domNode: oldDomNodes[i], vdomNode: c });
+    }
+  }
+  const newRemaining = newTail - newHead + 1;
+  const sequence = new Array(newRemaining);
+  for (let i = 0; i < newRemaining; i++) {
+    const nc = newChildren[newHead + i];
+    const cKey = nc.compareKey;
+    const entries = cKey ? keyMap[cKey] : void 0;
+    if (entries && entries.length > 0) {
+      const entry = entries.shift();
+      if (entries.length === 0) delete keyMap[cKey];
+      const oldIdx = oldChildren.indexOf(entry.vdomNode, headIdx);
+      sequence[i] = oldIdx >= 0 ? oldIdx : -1;
+      usedOldDomNodes.add(entry.domNode);
     } else {
-      if (!keyedNodes && newReusedTotal > 0 && oldReusedTotal > 0) {
-        keyedNodes = getKeyNodes(
-          oldChildren,
-          nodes,
-          oldStart,
-          oldEnd,
-          realEnd
-        );
-      }
-      const cKey = newStartNode.compareKey;
-      let found;
-      let compareKey;
-      if (cKey && keyedNodes) {
-        found = keyedNodes[cKey];
-        compareKey = void 0;
-        while (found && found.length > 0) {
-          compareKey = found.pop();
-          if (compareKey) break;
-        }
-        if (found && found.length === 0) delete keyedNodes[cKey];
-      }
-      if (compareKey) {
-        if (compareKey !== nodes[realStart]) {
-          for (let j = oldStart + 1; j <= oldEnd; j++) {
-            const oc = oldChildren?.[j];
-            if (oc && nodes[realStart + (j - oldStart)] === compareKey) {
-              oldChildren[j] = void 0;
-              break;
-            }
-          }
-          realNode.insertBefore(compareKey, nodes[realStart]);
-        }
-        vdomSetNode(
-          compareKey,
-          realNode,
-          oldStartNode,
-          newStartNode,
-          ref,
-          frame,
-          keys2,
-          view,
-          ready
-        );
-      } else if (oldStartNode.compareKey && lastVDom.reused?.[oldStartNode.compareKey] && newVDom.reused?.[oldStartNode.compareKey] || nodes[realStart]?.id && realNode.querySelectorAll?.(
-        `#${nodes[realStart].id}`
-      )?.length && !newStartNode.isLarkView) {
+      sequence[i] = -1;
+    }
+  }
+  if (newHead > newTail) {
+    for (let i = 0; i < oldLen; i++) {
+      const domNode = oldDomNodes[i];
+      if (domNode && !usedOldDomNodes.has(domNode) && domNode.parentNode === realNode) {
+        domUnmountFrames(frame, domNode);
         ref.changed = 1;
-        const newNode = vdomCreateNode(newStartNode, realNode, ref);
-        realNode.insertBefore(newNode, nodes[realStart]);
-        realStart--;
-        realEnd++;
-      } else {
-        vdomSetNode(
-          nodes[realStart],
-          realNode,
-          oldStartNode,
-          newStartNode,
-          ref,
-          frame,
-          keys2,
-          view,
-          ready
-        );
+        realNode.removeChild(domNode);
       }
-      realStart++;
-      oldStartNode = oldChildren?.[++oldStart];
-      newStartNode = newChildren?.[++newStart];
     }
+    if (ref.asyncCount === 0) callFunction(ready, []);
+    return;
   }
-  if (newStart <= newEnd) {
-    const refNode = nodes[realEnd + 1] || null;
-    for (let i = newStart; i <= newEnd; i++) {
+  if (headIdx > tailIdx) {
+    const insertRef = tailIdx < oldLen ? oldDomNodes[tailIdx + 1] ?? null : null;
+    for (let i = newHead; i <= newTail; i++) {
+      ref.changed = 1;
+      const newNode = vdomCreateNode(newChildren[i], realNode, ref);
+      realNode.insertBefore(newNode, insertRef);
+    }
+    if (ref.asyncCount === 0) callFunction(ready, []);
+    return;
+  }
+  const lis = computeLIS(sequence);
+  let lisCursor = lis.length - 1;
+  let nextNode = tailIdx + 1 < oldLen ? oldDomNodes[tailIdx + 1] : null;
+  for (let j = newRemaining - 1; j >= 0; j--) {
+    const newIdx = newHead + j;
+    const nc = newChildren[newIdx];
+    if (lisCursor >= 0 && lis[lisCursor] === j) {
+      const oldIdx = sequence[j];
+      vdomSetNode(
+        oldDomNodes[oldIdx],
+        realNode,
+        oldChildren[oldIdx],
+        nc,
+        ref,
+        frame,
+        keys2,
+        view,
+        ready
+      );
+      nextNode = oldDomNodes[oldIdx];
+      lisCursor--;
+    } else if (sequence[j] >= 0) {
+      const oldIdx = sequence[j];
+      ref.changed = 1;
+      realNode.insertBefore(oldDomNodes[oldIdx], nextNode);
+      vdomSetNode(
+        oldDomNodes[oldIdx],
+        realNode,
+        oldChildren[oldIdx],
+        nc,
+        ref,
+        frame,
+        keys2,
+        view,
+        ready
+      );
+      nextNode = oldDomNodes[oldIdx];
+    } else {
       ref.changed = 1;
-      const nc = newChildren[i];
-      if (nc.tag === SPLITTER) {
-        domUnmountFrames(frame, realNode);
-        realNode.innerHTML = nc.html;
-        return;
-      }
       const newNode = vdomCreateNode(nc, realNode, ref);
-      realNode.insertBefore(newNode, refNode);
+      realNode.insertBefore(newNode, nextNode);
+      nextNode = newNode;
     }
   }
-  if (oldStart <= oldEnd) {
-    for (let i = realEnd; i >= realStart; i--) {
-      const node = nodes[i];
-      if (node) {
-        domUnmountFrames(frame, node);
-        ref.changed = 1;
-        realNode.removeChild(node);
-      }
+  for (let i = 0; i < oldLen; i++) {
+    const domNode = oldDomNodes[i];
+    if (domNode && !usedOldDomNodes.has(domNode) && domNode.parentNode === realNode) {
+      domUnmountFrames(frame, domNode);
+      ref.changed = 1;
+      realNode.removeChild(domNode);
     }
   }
   if (ref.asyncCount === 0) {
     callFunction(ready, []);
   }
 }
-function reduceCached(keyedNodes, node, compared) {
-  if (!keyedNodes || !node.compareKey) return;
-  const bucket = keyedNodes[node.compareKey];
-  if (bucket) {
-    for (let i = bucket.length; i--; ) {
-      if (bucket[i] === compared) {
-        bucket[i] = void 0;
-        break;
-      }
-    }
-  }
-}
 function createVDomRef(viewId) {
   return {
     viewId,
@@ -2388,9 +2228,6 @@ var Updater = class {
     if (key) {
       result = this.data[key];
     }
-    if (typeof window !== "undefined" && window.__lark_Debug) {
-      return safeguard(result);
-    }
     return result;
   }
   /**
@@ -2478,9 +2315,6 @@ var Updater = class {
             view,
             ready
           );
-          if (ref.asyncCount === 0) {
-            ready();
-          }
         } else {
           const html = template(
             this.data,
@@ -2579,6 +2413,63 @@ var Updater = class {
   }
 };
 
+// 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/hmr.ts
+function reloadViews(viewPath) {
+  const allFrames = Frame.getAll();
+  const toReload = [];
+  for (const [, frame] of allFrames) {
+    if (frame.viewPath) {
+      const parsed = parseUri(frame.viewPath);
+      if (parsed.path === viewPath) {
+        toReload.push({ frame, fullPath: frame.viewPath });
+      }
+    }
+  }
+  for (const { frame, fullPath } of toReload) {
+    frame.mountView(fullPath);
+  }
+}
+function acceptView(hot, viewPath) {
+  hot.accept((newModule) => {
+    const candidate = newModule?.default ?? newModule;
+    if (typeof candidate === "function") {
+      const NewViewClass = candidate;
+      registerViewClass(viewPath, NewViewClass);
+      reloadViews(viewPath);
+    } else {
+      hot.invalidate();
+    }
+  });
+}
+function disposeView(hot, viewPath) {
+  hot.dispose(() => {
+    invalidateViewClass(viewPath);
+  });
+}
+
 // src/view.ts
 var VIEW_GLOBALS = {};
 if (typeof window !== "undefined") {
@@ -3169,34 +3060,51 @@ var View = class _View {
     _View.mergeMixins(mixins, this, existingCtors);
     return this;
   }
+  // ============================================================
+  // HMR support (static accept / dispose)
+  // ============================================================
+  /**
+   * Set up HMR accept handler for this view module.
+   *
+   * When the module is hot-replaced, the new View class is extracted from
+   * the new module, registered in the view registry, and all currently
+   * mounted frames using this viewPath are re-mounted.
+   *
+   * No-op when `hot` is undefined (production / non-HMR environment).
+   *
+   * ```ts
+   * if (import.meta.hot) {
+   *   HomeView.accept(import.meta.hot, 'home');
+   * }
+   * ```
+   */
+  static accept(hot, viewPath) {
+    if (!hot) return;
+    acceptView(hot, viewPath);
+  }
+  /**
+   * Set up HMR dispose handler for this view module.
+   *
+   * When the module is about to be replaced, the old View class is removed
+   * from the registry so subsequent lookups don't return the stale class.
+   *
+   * No-op when `hot` is undefined (production / non-HMR environment).
+   *
+   * ```ts
+   * if (import.meta.hot) {
+   *   HomeView.dispose(import.meta.hot, 'home');
+   * }
+   * ```
+   */
+  static dispose(hot, viewPath) {
+    if (!hot) return;
+    disposeView(hot, viewPath);
+  }
 };
 function defineView(props, statics) {
   return View.extend(props, statics);
 }
 
-// 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;
@@ -4654,10 +4562,6 @@ var Framework = {
    * Generate globally unique ID.
    */
   guid: generateId,
-  /**
-   * Proxy-based debug guard.
-   */
-  guard: safeguard,
   /**
    * Cache class.
    */
@@ -4878,8 +4782,8 @@ function bindStore(view, store, selector) {
   markRouterBooted,
   nextCounter,
   registerViewClass,
+  reloadViews,
   resetProjectsMap,
-  safeguard,
   unmark,
   use,
   useUrlState,