@lark.js/mvc 0.0.14 → 0.0.16

package/dist/devtool.cjs

@@ -82,10 +82,7 @@ var URI_ENT_MAP = {
 };
 var URI_ENT_REGEXP = /[!')(*]/g;
 function encodeURIExtra(v) {
-  return encodeURIComponent(strSafe(v)).replace(
-    URI_ENT_REGEXP,
-    (m) => URI_ENT_MAP[m]
-  );
+  return encodeURIComponent(strSafe(v)).replace(URI_ENT_REGEXP, (m) => URI_ENT_MAP[m]);
 }
 var QUOTE_ENT_REGEXP = /['"\\]/g;
 function encodeQuote(v) {
@@ -114,15 +111,20 @@ function isRefToken(s) {
 var CALL_BREAK_TIME = 9;
 var callQueue = [];
 var callScheduled = false;
-var schedulerYield = (() => {
+function getSchedulerYield() {
   try {
-    if (typeof globalThis?.scheduler?.yield === "function") {
-      return globalThis.scheduler.yield.bind(globalThis.scheduler);
+    const scheduler = Reflect.get(globalThis, "scheduler");
+    if (scheduler && typeof scheduler === "object" && typeof Reflect.get(scheduler, "yield") === "function") {
+      const yieldFn = Reflect.get(scheduler, "yield");
+      if (typeof yieldFn === "function") {
+        return yieldFn.bind(scheduler);
+      }
     }
   } catch {
   }
   return void 0;
-})();
+}
+var schedulerYield = getSchedulerYield();
 async function startCall() {
   callScheduled = false;
   const startTime = performance.now();
@@ -148,7 +150,9 @@ function scheduleNextChunk() {
   callScheduled = true;
 }
 function callFunction(fn, args) {
-  callQueue.push(() => fn(...args));
+  callQueue.push(() => {
+    fn(...args);
+  });
   if (!callScheduled) {
     scheduleNextChunk();
   }
@@ -165,7 +169,6 @@ function asRecord(value) {
   if (isRecord(value)) {
     return value;
   }
-  console.error("fallback to Object.fromEntries, even an empty object {}.");
   if (Array.isArray(value)) {
     return Object.fromEntries(value.entries());
   }
@@ -191,7 +194,7 @@ function assign(target, ...sources) {
     if (source) {
       for (const p in source) {
         if (hasOwnProperty(source, p)) {
-          target[p] = source[p];
+          Reflect.set(target, p, source[p]);
         }
       }
     }
@@ -230,16 +233,16 @@ function translateData(data, value) {
   if (isPrimitive(value)) {
     const prop = String(value);
     if (isRefToken(prop) && hasOwnProperty(data, prop)) {
-      return data[prop];
+      return Reflect.get(data, prop);
     }
     return value;
   }
   if (isPlainObject(value) || Array.isArray(value)) {
     for (const p in value) {
       if (hasOwnProperty(value, p)) {
-        const val = value[p];
+        const val = Reflect.get(value, p);
         const newVal = translateData(data, val);
-        value[p] = newVal;
+        Reflect.set(value, p, newVal);
       }
     }
     return value;
@@ -296,41 +299,30 @@ function toUri(path, params, keepEmpty) {
 }
 
 // src/event-emitter.ts
-var EventEmitter = class {
-  /** Event listeners: prefixed key -> listener array */
-  listeners = /* @__PURE__ */ new Map();
-  /** Number of `fire()` calls currently on the stack (re-entrancy depth). */
-  firingDepth = 0;
-  /** Keys whose listener list needs compaction after firing settles. */
-  pendingCompaction;
-  /**
-   * Bind event listener.
-   */
-  on(event, handler) {
+function createEmitter() {
+  const listeners = /* @__PURE__ */ new Map();
+  let firingDepth = 0;
+  let pendingCompaction;
+  function on(event, handler) {
     const key = SPLITTER + event;
-    let list = this.listeners.get(key);
+    let list = listeners.get(key);
     if (!list) {
       list = [];
-      this.listeners.set(key, list);
+      listeners.set(key, list);
     }
     list.push({ handler, executing: 0 });
-    return this;
+    return api;
   }
-  /**
-   * Unbind event listener.
-   * If handler is provided, removes only that handler.
-   * If no handler, removes all handlers for the event.
-   */
-  off(event, handler) {
+  function off(event, handler) {
     const key = SPLITTER + event;
     if (handler) {
-      const list = this.listeners.get(key);
-      if (!list) return this;
-      if (this.firingDepth > 0) {
+      const list = listeners.get(key);
+      if (!list) return api;
+      if (firingDepth > 0) {
         for (const listener of list) {
           if (listener.handler === handler) {
             listener.handler = noop;
-            (this.pendingCompaction ??= /* @__PURE__ */ new Set()).add(key);
+            (pendingCompaction ??= /* @__PURE__ */ new Set()).add(key);
             break;
           }
         }
@@ -341,35 +333,20 @@ var EventEmitter = class {
             break;
           }
         }
-        if (list.length === 0) this.listeners.delete(key);
+        if (list.length === 0) listeners.delete(key);
       }
     } else {
-      this.listeners.delete(key);
-      Reflect.deleteProperty(
-        this,
-        `on${event[0].toUpperCase() + event.slice(1)}`
-      );
+      listeners.delete(key);
+      Reflect.deleteProperty(internal, onMethodName(event));
     }
-    return this;
+    return api;
   }
-  /**
-   * Fire event, execute all bound handlers. Safe for re-entrant `off()` calls
-   * during dispatch: removed handlers are replaced with noop and compacted
-   * after the outermost fire returns.
-   *
-   * @param event - Event name
-   * @param data - Event data (type property added automatically)
-   * @param remove - Whether to remove all handlers after firing
-   * @param lastToFirst - Whether to execute handlers in reverse order
-   */
-  fire(event, data, remove, lastToFirst) {
+  function fire(event, data, remove, lastToFirst) {
     const key = SPLITTER + event;
-    const list = this.listeners.get(key);
-    if (!data) {
-      data = {};
-    }
-    data["type"] = event;
-    this.firingDepth++;
+    const list = listeners.get(key);
+    const eventData = data ?? {};
+    eventData["type"] = event;
+    firingDepth++;
     try {
       if (list) {
         const len = list.length;
@@ -379,35 +356,45 @@ var EventEmitter = class {
           if (!listener) continue;
           if (listener.handler === noop) continue;
           listener.executing = 1;
-          funcWithTry([listener.handler], [data], this, noop);
+          funcWithTry([listener.handler], [eventData], null, noop);
           listener.executing = "";
         }
       }
-      const onMethodName = `on${event[0].toUpperCase() + event.slice(1)}`;
-      const onMethod = this[onMethodName];
+      const onMethod = internal[onMethodName(event)];
       if (typeof onMethod === "function") {
-        funcWithTry([onMethod], [data], this, noop);
+        funcWithTry([onMethod], [eventData], null, noop);
       }
       if (remove) {
-        this.off(event);
+        off(event);
       }
     } finally {
-      this.firingDepth--;
-      if (this.firingDepth === 0 && this.pendingCompaction) {
-        for (const k of this.pendingCompaction) {
-          const l = this.listeners.get(k);
+      firingDepth--;
+      if (firingDepth === 0 && pendingCompaction) {
+        for (const k of pendingCompaction) {
+          const l = listeners.get(k);
           if (!l) continue;
           for (let i = l.length - 1; i >= 0; i--) {
             if (l[i].handler === noop) l.splice(i, 1);
           }
-          if (l.length === 0) this.listeners.delete(k);
+          if (l.length === 0) listeners.delete(k);
         }
-        this.pendingCompaction = void 0;
+        pendingCompaction = void 0;
       }
     }
-    return this;
+    return api;
   }
-};
+  function onMethodName(event) {
+    return "on" + event[0].toUpperCase() + event.slice(1);
+  }
+  const internal = {
+    on,
+    off,
+    fire,
+    listeners
+  };
+  const api = internal;
+  return api;
+}
 
 // src/mark.ts
 var hostStore = /* @__PURE__ */ new WeakMap();
@@ -425,68 +412,41 @@ function unmark(host) {
 function sortCacheEntries(a, b) {
   return b.frequency - a.frequency || b.lastTimestamp - a.lastTimestamp;
 }
-var Cache = class {
-  /** Cache entries array */
-  entries = [];
-  /** Fast lookup: prefixed key -> entry */
-  lookup = /* @__PURE__ */ new Map();
-  /** Buffer size for eviction */
-  bufferSize;
-  /** Maximum cache size */
-  maxSize;
-  /** Total capacity (maxSize + bufferSize) */
-  capacity;
-  /** Callback when entry is removed */
-  onRemove;
-  /** Sort comparator */
-  comparator;
-  constructor(options = {}) {
-    this.maxSize = options.maxSize ?? 20;
-    this.bufferSize = options.bufferSize ?? 5;
-    this.capacity = this.maxSize + this.bufferSize;
-    this.onRemove = options.onRemove;
-    this.comparator = options.sortComparator ?? sortCacheEntries;
-  }
-  /** Prefix a key with SPLITTER for namespace isolation */
-  prefixKey(key) {
+function createCache(options = {}) {
+  let entries = [];
+  const lookup = /* @__PURE__ */ new Map();
+  const maxSize = options.maxSize ?? 20;
+  const bufferSize = options.bufferSize ?? 5;
+  const capacity = maxSize + bufferSize;
+  const onRemove = options.onRemove;
+  const comparator = options.sortComparator ?? sortCacheEntries;
+  function prefixKey(key) {
     return SPLITTER + key;
   }
-  /**
-   * Get a cached value by key.
-   * Updates frequency and timestamp for cache sorting.
-   */
-  get(key) {
-    const prefixedKey = this.prefixKey(key);
-    const entry = this.lookup.get(prefixedKey);
+  function get(key) {
+    const prefixedKey = prefixKey(key);
+    const entry = lookup.get(prefixedKey);
     if (!entry) return void 0;
     entry.frequency++;
     entry.lastTimestamp = nextCounter();
     return entry.value;
   }
-  /**
-   * Iterate all cached values.
-   */
-  forEach(callback) {
-    for (const entry of this.entries) {
+  function forEach(callback) {
+    for (const entry of entries) {
       callback(entry.value);
     }
   }
-  /**
-   * Set or update a cached value.
-   * If key already exists, updates value and increments frequency.
-   * If cache exceeds capacity, triggers eviction.
-   */
-  set(key, value) {
-    const prefixedKey = this.prefixKey(key);
-    const existing = this.lookup.get(prefixedKey);
+  function set(key, value) {
+    const prefixedKey = prefixKey(key);
+    const existing = lookup.get(prefixedKey);
     if (existing) {
       existing.value = value;
       existing.frequency++;
       existing.lastTimestamp = nextCounter();
       return;
     }
-    if (this.entries.length >= this.capacity) {
-      this.evictEntries();
+    if (entries.length >= capacity) {
+      evictEntries();
     }
     const entry = {
       originalKey: key,
@@ -494,87 +454,76 @@ var Cache = class {
       frequency: 1,
       lastTimestamp: nextCounter()
     };
-    this.entries.push(entry);
-    this.lookup.set(prefixedKey, entry);
+    entries.push(entry);
+    lookup.set(prefixedKey, entry);
   }
-  /**
-   * Delete a cached entry. Removes it immediately from both the lookup map
-   * and the entries array so the GC can reclaim the value without waiting
-   * for the next eviction sweep.
-   */
-  del(key) {
-    const prefixedKey = this.prefixKey(key);
-    const entry = this.lookup.get(prefixedKey);
+  function del(key) {
+    const prefixedKey = prefixKey(key);
+    const entry = lookup.get(prefixedKey);
     if (!entry) return;
-    this.lookup.delete(prefixedKey);
-    const idx = this.entries.indexOf(entry);
-    if (idx !== -1) this.entries.splice(idx, 1);
-    if (this.onRemove) {
-      this.onRemove(key);
+    lookup.delete(prefixedKey);
+    const idx = entries.indexOf(entry);
+    if (idx !== -1) entries.splice(idx, 1);
+    if (onRemove) {
+      onRemove(key);
     }
   }
-  /**
-   * Check if a key exists in cache.
-   */
-  has(key) {
-    return this.lookup.has(this.prefixKey(key));
+  function has(key) {
+    return lookup.has(prefixKey(key));
   }
-  /** Get current cache size */
-  get size() {
-    return this.entries.length;
-  }
-  /** Clear all entries */
-  clear() {
-    if (this.onRemove) {
-      for (const entry of this.entries) {
-        this.onRemove(entry.originalKey);
+  function clear() {
+    if (onRemove) {
+      for (const entry of entries) {
+        onRemove(entry.originalKey);
       }
     }
-    this.entries = [];
-    this.lookup.clear();
+    entries = [];
+    lookup.clear();
   }
-  /**
-   * Evict the `bufferSize` worst entries from the cache.
-   *
-   * Uses single-pass partial selection (O(n·k)) instead of sorting the entire
-   * `entries` array (O(n log n)). For the typical `bufferSize = 5` this is
-   * effectively a linear scan with at most 5 in-bucket comparisons per
-   * iteration — and it avoids mutating the rest of `entries`.
-   */
-  evictEntries() {
-    const entries = this.entries;
-    const k = this.bufferSize;
-    if (k <= 0 || entries.length === 0) return;
-    if (entries.length <= k) {
+  function evictEntries() {
+    if (bufferSize <= 0 || entries.length === 0) return;
+    if (entries.length <= bufferSize) {
       for (const e of entries) {
-        this.lookup.delete(this.prefixKey(e.originalKey));
-        if (this.onRemove) this.onRemove(e.originalKey);
+        lookup.delete(prefixKey(e.originalKey));
+        if (onRemove) onRemove(e.originalKey);
       }
-      this.entries = [];
+      entries = [];
       return;
     }
-    const cmp = this.comparator;
     const worst = [];
     for (const entry of entries) {
-      if (worst.length < k) {
+      if (worst.length < bufferSize) {
         let i = worst.length;
-        while (i > 0 && cmp(entry, worst[i - 1]) > 0) i--;
+        while (i > 0 && comparator(entry, worst[i - 1]) > 0) i--;
         worst.splice(i, 0, entry);
-      } else if (cmp(entry, worst[k - 1]) > 0) {
+      } else if (comparator(entry, worst[bufferSize - 1]) > 0) {
         worst.pop();
         let i = worst.length;
-        while (i > 0 && cmp(entry, worst[i - 1]) > 0) i--;
+        while (i > 0 && comparator(entry, worst[i - 1]) > 0) i--;
         worst.splice(i, 0, entry);
       }
     }
     const evictSet = new Set(worst);
     for (const e of worst) {
-      this.lookup.delete(this.prefixKey(e.originalKey));
-      if (this.onRemove) this.onRemove(e.originalKey);
-    }
-    this.entries = entries.filter((e) => !evictSet.has(e));
-  }
-};
+      lookup.delete(prefixKey(e.originalKey));
+      if (onRemove) onRemove(e.originalKey);
+    }
+    entries = entries.filter((e) => !evictSet.has(e));
+  }
+  function getSize() {
+    return entries.length;
+  }
+  const api = {
+    get,
+    set,
+    del,
+    has,
+    clear,
+    forEach,
+    getSize
+  };
+  return api;
+}
 
 // src/event-delegator.ts
 var rootEvents = {};
@@ -582,7 +531,7 @@ var selectorEvents = {};
 var rangeEvents = {};
 var rangeFrames = {};
 var elementGuid = 0;
-var eventInfoCache = new Cache({
+var eventInfoCache = createCache({
   maxSize: 30,
   bufferSize: 10
 });
@@ -635,7 +584,7 @@ function findFrameInfo(current, eventType) {
       if (frame) {
         const view = frame.view;
         if (view) {
-          const selectorEntry = view.eventSelectorMap[eventType];
+          const selectorEntry = { selectors: [] };
           if (selectorEntry) {
             for (const selectorName of selectorEntry.selectors) {
               const entry = {
@@ -653,7 +602,7 @@ function findFrameInfo(current, eventType) {
               }
             }
           }
-          if (view.template && !backtrace) {
+          if (view.getTemplate() && !backtrace) {
             if (match && !match.id) {
               match.id = frameId;
             }
@@ -705,8 +654,9 @@ function domEventProcessor(domEvent) {
         const frame = frameId ? frameGetter?.(frameId) : void 0;
         const view = frame?.view;
         if (view) {
-          const eventName = handlerName + SPLITTER + eventType;
-          const fn = Reflect.get(view, eventName);
+          const eventKey = handlerName + "<" + eventType + ">";
+          const events = typeof view.getEvents === "function" ? view.getEvents() : void 0;
+          const fn = events?.[eventKey];
           if (fn) {
             const extendedEvent = domEvent;
             extendedEvent.eventTarget = target;
@@ -785,68 +735,6 @@ var EventDelegator = {
   }
 };
 
-// src/module-loader.ts
-var config = {
-  rootId: "root",
-  routeMode: "history",
-  hashbang: "#!",
-  error: (error) => {
-    throw error;
-  }
-};
-function use(names, callback) {
-  const nameList = typeof names === "string" ? [names] : names;
-  const loadPromise = (() => {
-    if (config.require) {
-      const result = config.require(nameList);
-      if (result && typeof result.then === "function") {
-        return result;
-      }
-      return Promise.resolve([]);
-    }
-    return Promise.all(
-      nameList.map((name) => {
-        const importPath = name.startsWith(".") || name.startsWith("/") ? name : `./${name}`;
-        return import(
-          /* @vite-ignore */
-          /* webpackIgnore: true */
-          importPath
-        ).then((mod) => {
-          return mod && (mod["__esModule"] || // For Webpack
-          typeof mod["default"] === "function") ? mod["default"] : mod;
-        }).catch((err) => {
-          const errorHandler = config.error;
-          if (errorHandler) {
-            errorHandler(err instanceof Error ? err : new Error(String(err)));
-          }
-          return void 0;
-        });
-      })
-    );
-  })();
-  if (callback) {
-    loadPromise.then((modules) => {
-      callback(...modules);
-    });
-  }
-  return loadPromise;
-}
-
-// src/frame-registry.ts
-var frameRegistry = /* @__PURE__ */ new Map();
-function getFrame(id) {
-  return frameRegistry.get(id);
-}
-function getAllFrames() {
-  return frameRegistry;
-}
-function registerFrame(id, frame) {
-  frameRegistry.set(id, frame);
-}
-function removeFrame(id) {
-  frameRegistry.delete(id);
-}
-
 // src/dom.ts
 var wrapMeta = {
   option: [1, "<select multiple>"],
@@ -1122,6 +1010,11 @@ function vdomCreateNode(vnode, owner, ref) {
   if (tag === V_TEXT_NODE) {
     return document.createTextNode(vnode.html);
   }
+  if (tag === SPLITTER) {
+    const template = document.createElement("template");
+    template.innerHTML = vnode.html;
+    return template.content.firstChild || document.createTextNode("");
+  }
   const sTag = typeof tag === "string" ? tag : tag.toString();
   const ns = VDOM_NS_MAP[sTag] || owner.namespaceURI;
   const el = document.createElementNS(ns, sTag);
@@ -1205,6 +1098,14 @@ function vdomSetNode(realNode, oldParent, lastVDom, newVDom, ref, frame, keys, r
     return;
   }
   if (lastTag === newTag) {
+    if (newTag === SPLITTER) {
+      if (lastVDom.html !== newVDom.html) {
+        ref.changed = 1;
+        domUnmountFrames(frame, realNode);
+        oldParent.replaceChild(vdomCreateNode(newVDom, oldParent, ref), realNode);
+      }
+      return;
+    }
     if (lastVDom.attrs === newVDom.attrs && lastVDom.html === newVDom.html) {
       if (newVDom.hasSpecials) {
         vdomSyncFormState(realNode, newVDom);
@@ -1213,12 +1114,7 @@ function vdomSetNode(realNode, oldParent, lastVDom, newVDom, ref, frame, keys, r
     }
     let attrChanged = 0;
     if (lastVDom.attrs !== newVDom.attrs || newVDom.hasSpecials) {
-      attrChanged = vdomSetAttributes(
-        realNode,
-        newVDom,
-        ref,
-        lastVDom
-      );
+      attrChanged = vdomSetAttributes(realNode, newVDom, ref, lastVDom);
       if (attrChanged) ref.changed = 1;
     }
     let updateChildren = true;
@@ -1232,16 +1128,7 @@ function vdomSetNode(realNode, oldParent, lastVDom, newVDom, ref, frame, keys, r
     }
     vdomSyncFormState(realNode, newVDom);
     if (updateChildren && !newVDom.selfClose) {
-      vdomSetChildNodes(
-        realNode,
-        lastVDom,
-        newVDom,
-        ref,
-        frame,
-        keys,
-        rootView,
-        ready
-      );
+      vdomSetChildNodes(realNode, lastVDom, newVDom, ref, frame, keys, rootView, ready);
     }
   } else {
     ref.changed = 1;
@@ -1311,17 +1198,7 @@ function vdomSetChildNodes(realNode, lastVDom, newVDom, ref, frame, keys, view,
     const nc = newChildren[newHead];
     if (!isSameVDomNode(nc, oc)) break;
     if (nc.tag === SPLITTER || oc.tag === SPLITTER) break;
-    vdomSetNode(
-      oldDomNodes[headIdx],
-      realNode,
-      oc,
-      nc,
-      ref,
-      frame,
-      keys,
-      view,
-      ready
-    );
+    vdomSetNode(oldDomNodes[headIdx], realNode, oc, nc, ref, frame, keys, view, ready);
     usedOldDomNodes.add(oldDomNodes[headIdx]);
     headIdx++;
     newHead++;
@@ -1331,17 +1208,7 @@ function vdomSetChildNodes(realNode, lastVDom, newVDom, ref, frame, keys, view,
     const nc = newChildren[newTail];
     if (!isSameVDomNode(nc, oc)) break;
     if (nc.tag === SPLITTER || oc.tag === SPLITTER) break;
-    vdomSetNode(
-      oldDomNodes[tailIdx],
-      realNode,
-      oc,
-      nc,
-      ref,
-      frame,
-      keys,
-      view,
-      ready
-    );
+    vdomSetNode(oldDomNodes[tailIdx], realNode, oc, nc, ref, frame, keys, view, ready);
     usedOldDomNodes.add(oldDomNodes[tailIdx]);
     tailIdx--;
     newTail--;
@@ -1464,113 +1331,88 @@ function createVDomRef(viewId) {
 }
 
 // src/updater.ts
-var Updater = class {
-  /** View ID (same as owner frame ID) */
-  viewId;
-  /** Current data object */
-  data;
-  /** Ref data for template rendering */
-  refData;
-  /** Changed keys in current digest cycle */
-  changedKeys = /* @__PURE__ */ new Set();
-  /** Whether data has changed since last digest */
-  hasChangedFlag = 0;
-  /**
-   * Digesting queue: supports re-digest during digest.
-   * Holds pending callbacks; `null` is used as a sentinel marking the start
-   * of an active digest cycle, so `runDigest` can detect re-entrant calls.
-   */
-  digestingQueue = [];
-  /** Monotonically increasing version, bumped each time data actually changes. */
-  version = 0;
-  /** Snapshot of `version` taken by `snapshot()`, used by `altered()`. */
-  snapshotVersion;
-  /** Last rendered VDOM tree (only used when virtualDom is enabled) */
-  vdom;
-  constructor(viewId) {
-    this.viewId = viewId;
-    this.data = { vId: viewId };
-    const refCounter = {};
-    refCounter[SPLITTER] = 1;
-    this.refData = refCounter;
-    this.hasChangedFlag = 1;
-  }
-  /**
-   * Get data by key.
-   * Returns entire data object if key is omitted.
-   */
-  get(key) {
-    let result = this.data;
+function createUpdater(viewId) {
+  let data = { vId: viewId };
+  const refData = {};
+  refData[SPLITTER] = 1;
+  let changedKeys = /* @__PURE__ */ new Set();
+  let hasChangedFlag = 0;
+  const digestingQueue = [];
+  let version = 0;
+  let snapshotVersion;
+  let vdom;
+  hasChangedFlag = 1;
+  function get(key) {
+    let result = data;
     if (key) {
-      result = this.data[key];
+      result = data[key];
     }
     return result;
   }
-  /**
-   * Set data, tracking changed keys.
-   * Returns this for chaining.
-   */
-  set(data, excludes) {
-    const changed = setData(
-      data,
-      this.data,
-      this.changedKeys,
-      excludes || EMPTY_STRING_SET
-    );
+  function set(newData, excludes) {
+    const changed = setData(newData, data, changedKeys, excludes || EMPTY_STRING_SET);
     if (changed) {
-      this.version++;
-      this.hasChangedFlag = 1;
+      version++;
+      hasChangedFlag = 1;
     }
-    return this;
+    return api;
   }
-  /**
-   * Detect changes and trigger DOM re-render.
-   *
-   * The core rendering pipeline:
-   * 1. Set data if provided
-   * 2. If changed, run DOM diff (template → new DOM → diff against old DOM)
-   * 3. Apply DOM operations
-   * 4. Apply ID updates
-   * 5. Call endUpdate on views that need re-rendering
-   * 6. Support re-digest during digest via queue
-   */
-  digest(data, excludes, callback) {
-    if (data) {
-      this.set(data, excludes);
+  function digest(newData, excludes, callback) {
+    if (newData) {
+      set(newData, excludes);
     }
-    const digesting = this.digestingQueue;
     if (callback) {
-      digesting.push(callback);
+      digestingQueue.push(callback);
     }
-    if (digesting.length > 0 && digesting[0] === null) {
+    if (digestingQueue.length > 0 && digestingQueue[0] === null) {
       return;
     }
-    this.runDigest(digesting);
+    runDigest(digestingQueue);
   }
-  /**
-   * Core digest execution.
-   */
-  runDigest(digesting) {
+  function runDigest(digesting) {
     const startIndex = digesting.length;
     digesting.push(null);
-    const keys = this.changedKeys;
-    const changed = this.hasChangedFlag;
-    this.hasChangedFlag = 0;
-    this.changedKeys = /* @__PURE__ */ new Set();
-    const frame = getFrame(this.viewId);
+    const keys = changedKeys;
+    const changed = hasChangedFlag;
+    const frame = Frame.get(viewId);
     const view = frame?.view;
-    const node = getById(this.viewId);
-    if (changed && view && node && view.signature > 0 && frame) {
-      const template = view.template;
+    const node = getById(viewId);
+    if (changed && view && node && view.signature.value > 0 && frame) {
+      hasChangedFlag = 0;
+      changedKeys = /* @__PURE__ */ new Set();
+      const template = view.getTemplate();
       if (typeof template === "function") {
-        if (config.virtualDom) {
-          const vdomTemplate = template;
-          const newVDom = vdomTemplate(this.data, this.viewId, this.refData);
-          const ref = createVDomRef(this.viewId);
+        const result = template(
+          data,
+          viewId,
+          refData,
+          encodeHTML,
+          strSafe,
+          encodeURIExtra,
+          refFn,
+          encodeQuote
+        );
+        if (typeof result === "string") {
+          const newDom = domGetNode(result, node);
+          const ref = createDomRef();
+          domSetChildNodes(node, newDom, ref, frame, keys);
+          applyIdUpdates(ref.idUpdates);
+          applyDomOps(ref.domOps);
+          for (const v of ref.views) {
+            if (v.render) {
+              funcWithTry(v.render, [], v, noop);
+            }
+          }
+          if (ref.hasChanged || !view.rendered.value) {
+            view.endUpdate(viewId);
+          }
+        } else {
+          const newVDom = result;
+          const ref = createVDomRef(viewId);
           const ready = () => {
-            this.vdom = newVDom;
-            if (ref.changed || !view.rendered) {
-              view.endUpdate(this.viewId);
+            vdom = newVDom;
+            if (ref.changed || !view.rendered.value) {
+              view.endUpdate(viewId);
             }
             for (const [el, prop, val] of ref.nodeProps) {
               Reflect.set(el, prop, val);
@@ -1581,45 +1423,14 @@ var Updater = class {
               }
             }
           };
-          vdomSetChildNodes(
-            node,
-            this.vdom,
-            newVDom,
-            ref,
-            frame,
-            keys,
-            view,
-            ready
-          );
-        } else {
-          const html = template(
-            this.data,
-            this.viewId,
-            this.refData,
-            encodeHTML,
-            strSafe,
-            encodeURIExtra,
-            refFn,
-            encodeQuote
-          );
-          const newDom = domGetNode(html, node);
-          const ref = createDomRef();
-          domSetChildNodes(node, newDom, ref, frame, keys);
-          applyIdUpdates(ref.idUpdates);
-          applyDomOps(ref.domOps);
-          for (const v of ref.views) {
-            if (v.render) {
-              funcWithTry(v.render, [], v, noop);
-            }
-          }
-          if (ref.hasChanged || !view.rendered) {
-            view.endUpdate(this.viewId);
-          }
+          vdomSetChildNodes(node, vdom, newVDom, ref, frame, keys, view, ready);
         }
       }
+    } else {
+      changedKeys = /* @__PURE__ */ new Set();
     }
     if (digesting.length > startIndex + 1) {
-      this.runDigest(digesting);
+      runDigest(digesting);
     } else {
       const callbacks = digesting.slice();
       digesting.length = 0;
@@ -1628,44 +1439,19 @@ var Updater = class {
       }
     }
   }
-  /**
-   * Save a snapshot of the current data version for `altered()` detection.
-   * Cheap O(1) — records the current monotonic version, no serialization.
-   */
-  snapshot() {
-    this.snapshotVersion = this.version;
-    return this;
+  function snapshot() {
+    snapshotVersion = version;
+    return api;
   }
-  /**
-   * Check whether data has changed since the last snapshot.
-   * Returns undefined when no snapshot has been taken yet.
-   */
-  altered() {
-    if (this.snapshotVersion === void 0) return void 0;
-    return this.version !== this.snapshotVersion;
+  function altered() {
+    if (snapshotVersion === void 0) return void 0;
+    return version !== snapshotVersion;
   }
-  /**
-   * Translate a refData reference back to its original value.
-   *
-   * The ref protocol is `SPLITTER` + ascii decimal digits — the exact format
-   * emitted by `refFn`. We require that exact shape so a user-supplied
-   * string that merely begins with SPLITTER is never accidentally resolved
-   * (or mishandled as a "missing ref").
-   */
-  translate(data) {
-    if (typeof data !== "string" || !isRefToken(data)) return data;
-    return hasOwnProperty(this.refData, data) ? this.refData[data] : data;
+  function translate(dataVal) {
+    if (typeof dataVal !== "string" || !isRefToken(dataVal)) return dataVal;
+    return hasOwnProperty(refData, dataVal) ? refData[dataVal] : dataVal;
   }
-  /**
-   * Resolve a dotted property path against refData.
-   *
-   * Only safe property-path syntax is supported: `a`, `a.b`, `a.b.c`.
-   * Numeric literals (e.g. `1`, `1.5`) are returned as numbers. Anything else
-   * returns `undefined` — we no longer evaluate arbitrary JavaScript via
-   * `new Function`, so the method is CSP-safe and cannot be used as an
-   * injection vector.
-   */
-  parse(expr) {
+  function parse(expr) {
     const trimmed = expr.trim();
     if (!trimmed) return void 0;
     if (/^-?\d+(?:\.\d+)?$/.test(trimmed)) {
@@ -1674,25 +1460,40 @@ var Updater = class {
     if (!/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*$/.test(trimmed)) {
       return void 0;
     }
-    let cur = this.refData;
+    let cur = refData;
     for (const segment of trimmed.split(".")) {
       if (cur == null || typeof cur !== "object") return void 0;
-      cur = cur[segment];
+      cur = Reflect.get(cur, segment);
     }
     return cur;
   }
-  /**
-   * Get the set of keys changed since the last digest (for external inspection).
-   */
-  getChangedKeys() {
-    return this.changedKeys;
-  }
-};
+  function getChangedKeys() {
+    return changedKeys;
+  }
+  function forceDigest() {
+    hasChangedFlag = 1;
+    changedKeys = new Set(Object.keys(data));
+    digest();
+  }
+  const api = {
+    get,
+    set,
+    digest,
+    forceDigest,
+    snapshot,
+    altered,
+    refData,
+    translate,
+    parse,
+    getChangedKeys
+  };
+  return api;
+}
 
 // src/router.ts
-var emitter = new EventEmitter();
-var hrefCache = new Cache();
-var changedCache = new Cache();
+var emitter = createEmitter();
+var hrefCache = createCache();
+var changedCache = createCache();
 var lastLocation = createEmptyLocation();
 var lastChanged;
 var silent = 0;
@@ -1736,11 +1537,7 @@ function attachViewAndPath(loc) {
       path = cachedDefaultPath;
     }
     if (cachedRewrite) {
-      path = cachedRewrite(
-        path,
-        loc["params"],
-        cachedRoutes
-      );
+      path = cachedRewrite(path, loc["params"], cachedRoutes);
     }
     const viewEntry = cachedRoutes[path] || cachedUnmatchedView || cachedDefaultView;
     loc["path"] = path;
@@ -1943,7 +1740,7 @@ var Router = {
     updateUrl(tPath, tParams, lastLocation, replace, silentFlag, lQuery);
   },
   /**
-   * Register an async-friendly navigation guard. See `RouterInterface.beforeEach`.
+   * Register an async-friendly navigation guard. See `RouterApi.beforeEach`.
    */
   beforeEach(guard) {
     beforeEachGuards.push(guard);
@@ -2081,62 +1878,10 @@ var Router = {
   }
 };
 
-// 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);
-  }
-}
-
-// src/hmr.ts
-function reloadViews(viewPath) {
-  const allFrames = getAllFrames();
-  const toReload = [];
-  for (const [, frame] of allFrames) {
-    if (frame.viewPath) {
-      const parsed = parseUri(frame.viewPath);
-      if (parsed.path === viewPath) {
-        toReload.push({ frame, fullPath: frame.viewPath });
-      }
-    }
-  }
-  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);
-      return;
-    }
-    if (getViewClass(viewPath)) {
-      reloadViews(viewPath);
-      return;
-    }
-    hot.invalidate();
-  });
-}
-function disposeView(hot, viewPath) {
-  hot.dispose(() => {
-    invalidateViewClass(viewPath);
-  });
+// src/hooks.ts
+var currentCtx = null;
+function setCurrentCtx(ctx) {
+  currentCtx = ctx;
 }
 
 // src/view.ts
@@ -2147,161 +1892,99 @@ if (typeof window !== "undefined") {
 if (typeof document !== "undefined") {
   VIEW_GLOBALS["document"] = document;
 }
-var View = class _View {
-  /** View ID (same as owner frame ID) */
-  id = "";
-  /** Owner frame */
-  owner = 0;
-  /** Updater instance */
-  updater;
-  /** Signature: > 0 means active, incremented on render, 0 = destroyed */
-  signature = 0;
-  /** Whether rendered at least once */
-  rendered;
-  /** Whether view has template */
-  template;
-  /** Location observation config */
-  locationObserved = {
+function createCtx(frame) {
+  const id = frame.id;
+  const updater = createUpdater(id);
+  const emitter2 = createEmitter();
+  const signature = { value: 0 };
+  const rendered = { value: false };
+  const resources = {};
+  const locationObserved = {
     flag: 0,
     keys: [],
     observePath: false
   };
-  /** Observed state keys */
-  observedStateKeys;
-  /** Resource map */
-  resources = {};
-  /** Whether endUpdate pending */
-  endUpdatePending;
-  /** Internal event storage */
-  _events = new EventEmitter();
-  // ============================================================
-  // Getters for prototype-stored event maps
-  // ============================================================
-  /** Prototype-stored event maps shape (set by View.prepare). */
-  get protoEventState() {
-    return Object.getPrototypeOf(this);
-  }
-  /**
-   * Event bitmask map: eventType -> bitmask (1=root, 2=selector).
-   * Read from prototype ($evtObjMap) set by View.prepare.
-   * Using a getter avoids ES6 class field shadowing the prototype value.
-   */
-  get eventObjectMap() {
-    return this.protoEventState.$evtObjMap ?? {};
-  }
-  /**
-   * Selector event map: eventType -> selector list.
-   * Read from prototype ($selMap) set by View.prepare.
-   */
-  get eventSelectorMap() {
-    return this.protoEventState.$selMap ?? {};
+  const mutable = {
+    observedStateKeys: void 0,
+    endUpdatePending: void 0,
+    template: void 0,
+    events: void 0,
+    assignFn: void 0
+  };
+  const cleanups = [];
+  function on(event, handler) {
+    emitter2.on(event, handler);
+    return () => emitter2.off(event, handler);
   }
-  /**
-   * Global event list: [{handler, element, eventName, modifiers}].
-   * Read from prototype ($globalEvtList) set by View.prepare.
-   */
-  get globalEventList() {
-    return this.protoEventState.$globalEvtList ?? [];
+  function off(event, handler) {
+    emitter2.off(event, handler);
   }
-  // ============================================================
-  // Instance lifecycle methods
-  // ============================================================
-  /**
-   * Initialize view (called by Frame when mounting).
-   */
-  init() {
+  function fire(event, data, remove, lastToFirst) {
+    emitter2.fire(event, data, remove, lastToFirst);
   }
-  /**
-   * Render view template (called by Frame after init).
-   * Wrapped by View.wrapMethod to manage signature + resources.
-   */
-  render() {
-    this.updater.digest();
-  }
-  // ============================================================
-  // Event methods (delegate to internal EventEmitter)
-  // ============================================================
-  on(event, handler) {
-    this._events.on(event, handler);
-    return this;
-  }
-  off(event, handler) {
-    this._events.off(event, handler);
-    return this;
+  function capture(key, resource, destroyOnRender = false) {
+    if (resource !== void 0) {
+      destroyResource(resources, key, true, resource);
+      resources[key] = { entity: resource, destroyOnRender };
+    } else {
+      const entry = resources[key];
+      return entry ? entry.entity : void 0;
+    }
+    return resource;
   }
-  fire(event, data, remove, lastToFirst) {
-    this._events.fire(event, data, remove, lastToFirst);
-    return this;
+  function release(key, destroy = true) {
+    return destroyResource(resources, key, destroy);
   }
-  // ============================================================
-  // Update methods
-  // ============================================================
-  /** Get the owning frame, asserting it has been bound. */
-  get ownerFrame() {
-    return this.owner;
+  function render() {
+    if (signature.value > 0) {
+      signature.value++;
+      fire("render");
+      destroyAllResources(ctx, false);
+      if (typeof ctx.renderMethod === "function") {
+        funcWithTry(ctx.renderMethod, [], ctx, noop);
+      } else {
+        updater.digest();
+      }
+    }
   }
-  /**
-   * Notify view that HTML update is about to begin.
-   * Unmounts child frames in the update zone.
-   */
-  beginUpdate(id) {
-    if (this.signature > 0 && this.endUpdatePending !== void 0) {
-      this.ownerFrame.unmountZone(id);
+  function beginUpdate(zoneId) {
+    if (signature.value > 0 && mutable.endUpdatePending !== void 0) {
+      frame.unmountZone(zoneId);
     }
   }
-  /**
-   * Notify view that HTML update has ended.
-   * Mounts child frames in the update zone and runs deferred invokes.
-   */
-  endUpdate(id, inner) {
-    if (this.signature > 0) {
-      const updateId = id || this.id;
+  function endUpdate(zoneId, inner) {
+    if (signature.value > 0) {
+      const updateId = zoneId ?? id;
       let flag;
       if (inner) {
         flag = inner;
       } else {
-        flag = this.endUpdatePending;
-        this.endUpdatePending = 1;
-        this.rendered = true;
+        flag = mutable.endUpdatePending;
+        mutable.endUpdatePending = 1;
+        rendered.value = true;
       }
-      const ownerFrame = this.ownerFrame;
-      ownerFrame.mountZone(updateId);
+      frame.mountZone(updateId);
       if (!flag) {
         setTimeout(
-          this.wrapAsync(() => {
-            _View.runInvokes(ownerFrame);
+          wrapAsync(() => {
+            runInvokes(frame);
           }),
           0
         );
       }
     }
   }
-  // ============================================================
-  // Async wrapper
-  // ============================================================
-  /**
-   * Wrap an async callback to check view signature before executing.
-   * If the view has been re-rendered or destroyed, the callback is skipped.
-   */
-  wrapAsync(fn, context) {
-    const currentSignature = this.signature;
+  function wrapAsync(fn, context) {
+    const currentSignature = signature.value;
     return (...args) => {
-      if (currentSignature > 0 && currentSignature === this.signature) {
-        return fn.apply(context || this, args);
+      if (currentSignature > 0 && currentSignature === signature.value) {
+        return fn.apply(context ?? ctx, args);
       }
       return void 0;
     };
   }
-  // ============================================================
-  // Location observation
-  // ============================================================
-  /**
-   * Observe location parameters or path changes.
-   * When observed keys change, render() is called automatically.
-   */
-  observeLocation(params, observePath = false) {
-    const loc = this.locationObserved;
-    loc.flag = 1;
+  function observeLocation(params, observePath = false) {
+    locationObserved.flag = 1;
     if (typeof params === "object" && !Array.isArray(params)) {
       const opts = params;
       if (opts["path"]) {
@@ -2312,880 +1995,634 @@ var View = class _View {
         params = paramKeys;
       }
     }
-    loc.observePath = observePath;
+    locationObserved.observePath = observePath;
     if (params) {
       if (typeof params === "string") {
-        loc.keys = params.split(",");
+        locationObserved.keys = params.split(",");
       } else if (Array.isArray(params)) {
-        loc.keys = params;
+        locationObserved.keys = params;
       }
     }
   }
-  // ============================================================
-  // State observation
-  // ============================================================
-  /**
-   * Observe State data keys for changes.
-   * When observed keys change via State.digest(), render() is called.
-   */
-  observeState(observedKeys) {
-    if (typeof observedKeys === "string") {
-      this.observedStateKeys = observedKeys.split(",");
+  function observeState(keys) {
+    if (typeof keys === "string") {
+      mutable.observedStateKeys = keys.split(",");
     } else {
-      this.observedStateKeys = observedKeys;
+      mutable.observedStateKeys = keys;
     }
   }
-  // ============================================================
-  // Resource management
-  // ============================================================
-  /**
-   * Capture (register) a resource under a key.
-   * If a resource already exists at that key, it's destroyed first.
-   * When destroyOnRender=true, the resource is destroyed on next render call.
-   */
-  capture(key, resource, destroyOnRender = false) {
-    const cache = this.resources;
-    if (resource) {
-      _View.destroyResource(cache, key, true, resource);
-      cache[key] = {
-        entity: resource,
-        destroyOnRender
-      };
-    } else {
-      const entry = cache[key];
-      return entry ? entry.entity : void 0;
+  function leaveTip(message, condition) {
+    const changeState = { a: 0, b: 0 };
+    function isRouteChange(e) {
+      return "prevent" in e && "reject" in e && "resolve" in e;
     }
-    return resource;
-  }
-  /**
-   * Release a captured resource.
-   * If destroy=true, calls the resource's destroy() method.
-   */
-  release(key, destroy = true) {
-    return _View.destroyResource(this.resources, key, destroy);
-  }
-  // ============================================================
-  // Leave tip
-  // ============================================================
-  /**
-   * Set up a leave confirmation for route changes and page unload.
-   */
-  leaveTip(message, condition) {
-    const changeListener = function(e) {
+    const changeListener = (e) => {
+      if (!e) return;
       const isRouterChange = e.type === RouterEvents.CHANGE;
       const aKey = isRouterChange ? "a" : "b";
       const bKey = isRouterChange ? "b" : "a";
-      if (changeListener[aKey]) {
-        e.prevent?.();
-        e.reject?.();
+      if (changeState[aKey]) {
+        if (isRouteChange(e)) {
+          e.prevent();
+          e.reject();
+        }
       } else if (condition()) {
-        e.prevent?.();
-        changeListener[bKey] = 1;
-        e.resolve?.();
+        if (isRouteChange(e)) {
+          e.prevent();
+          changeState[bKey] = 1;
+          e.resolve();
+        }
       }
     };
     const unloadListener = (e) => {
-      if (condition()) {
-        e["msg"] = message;
+      if (e && condition()) {
+        Reflect.set(e, "msg", message);
       }
     };
     Router.on(RouterEvents.CHANGE, changeListener);
     Router.on(RouterEvents.PAGE_UNLOAD, unloadListener);
-    this.on("unload", changeListener);
-    this.on("destroy", () => {
+    on("unload", changeListener);
+    on("destroy", () => {
       Router.off(RouterEvents.CHANGE, changeListener);
       Router.off(RouterEvents.PAGE_UNLOAD, unloadListener);
     });
   }
-  // ============================================================
-  // Static public methods
-  // ============================================================
-  /** Collected makes from mixins */
-  static makes;
-  /**
-   * Prepare a View subclass by scanning its prototype for event method patterns.
-   * Pattern: `$?name<eventType1,eventType2>(&modifiers)`
-   *
-   * Only runs once per View subclass (guarded by makes marker).
-   * Called from Frame.mountView before creating the view instance.
-   */
-  static prepare(oView) {
-    if (oView.makes) {
-      return oView.makes;
-    }
-    const makes = [];
-    oView.makes = makes;
-    const eventsObject = {};
-    const eventsList = [];
-    const selectorObject = {};
-    const mixins = Reflect.get(oView.prototype, "mixins");
-    if (mixins && Array.isArray(mixins)) {
-      _View.mergeMixins(mixins, oView, makes);
-    }
-    for (const p in oView.prototype) {
-      if (!hasOwnProperty(oView.prototype, p)) continue;
-      const currentFn = Reflect.get(oView.prototype, p);
-      if (typeof currentFn !== "function") continue;
-      const matches = p.match(VIEW_EVENT_METHOD_REGEXP);
-      if (!matches) continue;
-      const isSelector = matches[1];
-      const selectorOrCallback = matches[2];
-      const events = matches[3];
-      const modifiers = matches[4];
-      const mod = {};
-      if (modifiers) {
-        for (const item of modifiers.split(",")) {
-          mod[item] = true;
-        }
-      }
-      const eventTypes = events.split(",");
-      for (const item of eventTypes) {
-        const globalNode = VIEW_GLOBALS[selectorOrCallback];
-        let mask = 1;
-        if (isSelector) {
-          if (globalNode) {
-            eventsList.push({
-              handler: currentFn,
-              element: globalNode,
-              eventName: item,
-              modifiers: mod
-            });
-            continue;
-          }
-          mask = 2;
-          let selectorEntry = selectorObject[item];
-          if (!selectorEntry) {
-            selectorEntry = selectorObject[item] = {
-              selectors: []
-            };
-          }
-          if (!selectorEntry[selectorOrCallback]) {
-            selectorEntry[selectorOrCallback] = 1;
-            selectorEntry.selectors.push(selectorOrCallback);
-          }
-        }
-        eventsObject[item] = (eventsObject[item] || 0) | mask;
-        const combinedKey = selectorOrCallback + SPLITTER + item;
-        const existingFn = Reflect.get(oView.prototype, combinedKey);
-        if (!existingFn) {
-          Reflect.set(oView.prototype, combinedKey, currentFn);
-        } else if (typeof existingFn === "function") {
-          const mixinFn = currentFn;
-          const existingMixin = existingFn;
-          if (existingMixin.marker) {
-            if (mixinFn.marker) {
-              Reflect.set(
-                oView.prototype,
-                combinedKey,
-                _View.processMixinsSameEvent(mixinFn, existingMixin)
-              );
-            } else if (hasOwnProperty(oView.prototype, p)) {
-              Reflect.set(oView.prototype, combinedKey, currentFn);
-            }
-          }
-        }
+  function init(_params) {
+  }
+  function getTemplate() {
+    return mutable.template;
+  }
+  function setTemplate(v) {
+    mutable.template = v;
+  }
+  function getObservedStateKeys() {
+    return mutable.observedStateKeys;
+  }
+  function setObservedStateKeys(v) {
+    mutable.observedStateKeys = v;
+  }
+  function getEndUpdatePending() {
+    return mutable.endUpdatePending;
+  }
+  function setEndUpdatePending(v) {
+    mutable.endUpdatePending = v;
+  }
+  function getEvents() {
+    return mutable.events;
+  }
+  function setEvents(v) {
+    mutable.events = v;
+  }
+  function getAssign() {
+    return mutable.assignFn;
+  }
+  function setAssign(v) {
+    mutable.assignFn = v;
+  }
+  const ctx = {
+    id,
+    owner: frame,
+    updater,
+    signature,
+    rendered,
+    getTemplate,
+    setTemplate,
+    locationObserved,
+    getObservedStateKeys,
+    setObservedStateKeys,
+    resources,
+    emitter: emitter2,
+    getEndUpdatePending,
+    setEndUpdatePending,
+    getEvents,
+    setEvents,
+    cleanups,
+    getAssign,
+    setAssign,
+    render,
+    init,
+    beginUpdate,
+    endUpdate,
+    wrapAsync,
+    observeLocation,
+    observeState,
+    capture,
+    release,
+    leaveTip,
+    fire,
+    on,
+    off
+  };
+  return ctx;
+}
+function registerEvents(ctx) {
+  const events = ctx.getEvents();
+  if (!events) return;
+  for (const key of Object.keys(events)) {
+    if (!hasOwnProperty(events, key)) continue;
+    const handler = events[key];
+    if (typeof handler !== "function") continue;
+    const matches = key.match(VIEW_EVENT_METHOD_REGEXP);
+    if (!matches) continue;
+    const isSelector = matches[1];
+    const selectorOrCallback = matches[2];
+    const eventTypes = matches[3];
+    const modifiers = matches[4];
+    const mod = {};
+    if (modifiers) {
+      for (const item of modifiers.split(",")) {
+        mod[item] = true;
+      }
+    }
+    for (const eventType of eventTypes.split(",")) {
+      const globalNode = VIEW_GLOBALS[selectorOrCallback];
+      if (isSelector && globalNode) {
+        registerGlobalEvent(ctx, globalNode, eventType, handler, mod, key);
+      } else if (isSelector) {
+        EventDelegator.bind(eventType, true);
+      } else {
+        EventDelegator.bind(eventType, false);
+      }
+    }
+  }
+}
+function unregisterEvents(ctx) {
+  const events = ctx.getEvents();
+  if (!events) return;
+  for (const key of Object.keys(events)) {
+    if (!hasOwnProperty(events, key)) continue;
+    const matches = key.match(VIEW_EVENT_METHOD_REGEXP);
+    if (!matches) continue;
+    const isSelector = matches[1];
+    const selectorOrCallback = matches[2];
+    const eventTypes = matches[3];
+    for (const eventType of eventTypes.split(",")) {
+      const globalNode = VIEW_GLOBALS[selectorOrCallback];
+      if (isSelector && globalNode) {
+      } else if (isSelector) {
+        EventDelegator.unbind(eventType, true);
+      } else {
+        EventDelegator.unbind(eventType, false);
       }
     }
-    _View.wrapMethod(asRecord(oView.prototype), "render", "$renderWrap");
-    Reflect.set(oView.prototype, "$evtObjMap", eventsObject);
-    Reflect.set(oView.prototype, "$globalEvtList", eventsList);
-    Reflect.set(oView.prototype, "$selMap", selectorObject);
-    return makes;
   }
-  /**
-   * Bind or unbind event delegation for a view instance.
-   * Called from Frame during mount/unmount.
-   */
-  static delegateEvents(view, destroy = false) {
-    const eventsObject = view.eventObjectMap;
-    const selectorObject = view.eventSelectorMap;
-    const eventsList = view.globalEventList;
-    for (const e in eventsObject) {
-      if (hasOwnProperty(eventsObject, e)) {
-        if (destroy) {
-          EventDelegator.unbind(e, !!selectorObject[e]);
-        } else {
-          EventDelegator.bind(e, !!selectorObject[e]);
+  EventDelegator.clearRangeEvents(ctx.id);
+}
+function registerGlobalEvent(ctx, element, eventName, handler, modifiers, _key) {
+  const listener = {
+    handleEvent(domEvent) {
+      Reflect.set(domEvent, "eventTarget", element);
+      if (modifiers) {
+        const ctrlKey = Reflect.get(domEvent, "ctrlKey");
+        const shiftKey = Reflect.get(domEvent, "shiftKey");
+        const altKey = Reflect.get(domEvent, "altKey");
+        const metaKey = Reflect.get(domEvent, "metaKey");
+        if (modifiers["ctrl"] && !ctrlKey || modifiers["shift"] && !shiftKey || modifiers["alt"] && !altKey || modifiers["meta"] && !metaKey) {
+          return;
         }
       }
+      funcWithTry(handler, [domEvent], ctx, noop);
     }
-    for (const entry of eventsList) {
-      if (destroy) {
-        entry.element.removeEventListener(
-          entry.eventName,
-          entry.boundHandler
-        );
-      } else {
-        const handler = entry.handler;
-        const element = entry.element;
-        const modifiers = entry.modifiers;
-        entry.boundHandler = function(domEvent) {
-          const extendedEvent = domEvent;
-          extendedEvent.eventTarget = element;
-          if (modifiers) {
-            const kbEvent = domEvent;
-            if (modifiers["ctrl"] && !kbEvent.ctrlKey || modifiers["shift"] && !kbEvent.shiftKey || modifiers["alt"] && !kbEvent.altKey || modifiers["meta"] && !kbEvent.metaKey) {
-              return;
-            }
-          }
-          funcWithTry(handler, [domEvent], view, noop);
-        };
-        entry.element.addEventListener(
-          entry.eventName,
-          entry.boundHandler
-        );
+  };
+  element.addEventListener(eventName, listener);
+  ctx.on("destroy", () => {
+    element.removeEventListener(eventName, listener);
+  });
+}
+function destroyAllResources(ctx, lastly) {
+  const cache = ctx.resources;
+  for (const p in cache) {
+    if (hasOwnProperty(cache, p)) {
+      const entry = cache[p];
+      if (lastly || entry.destroyOnRender) {
+        destroyResource(cache, p, true);
       }
     }
   }
-  /**
-   * Destroy all resources managed by a view.
-   * If lastly=true, destroy ALL resources; otherwise only destroyOnRender ones.
-   */
-  static destroyAllResources(view, lastly) {
-    const cache = view.resources;
-    for (const p in cache) {
-      if (hasOwnProperty(cache, p)) {
-        const entry = cache[p];
-        if (lastly || entry.destroyOnRender) {
-          _View.destroyResource(cache, p, true);
-        }
-      }
+}
+function destroyResource(cache, key, callDestroy, oldEntity) {
+  const entry = cache[key];
+  if (!entry || entry.entity === oldEntity) return void 0;
+  const entity = entry.entity;
+  if (entity && typeof entity === "object") {
+    const destroyFn = Reflect.get(entity, "destroy");
+    if (typeof destroyFn === "function" && callDestroy) {
+      funcWithTry(destroyFn, [], entity, noop);
     }
   }
-  /**
-   * Process deferred invoke calls on a frame.
-   */
-  static runInvokes(frame) {
-    const list = frame.invokeList;
-    if (!list) return;
-    while (list.length) {
-      const entry = list.shift();
-      if (entry && !entry.removed) {
-        frame.invoke(entry.name, entry.args);
-      }
+  Reflect.deleteProperty(cache, key);
+  return entity;
+}
+function runInvokes(frame) {
+  const list = frame.invokeList;
+  if (!list) return;
+  while (list.length) {
+    const entry = list.shift();
+    if (entry && !entry.removed) {
+      frame.invoke(entry.name, entry.args);
     }
   }
-  // ============================================================
-  // Static private methods
-  // ============================================================
-  /**
-   * Wrap a method on the prototype to add signature checking and resource cleanup.
-   */
-  static wrapMethod(proto, fnName, shortKey) {
-    const originalFn = proto[fnName];
-    if (typeof originalFn !== "function") return;
-    const originalAsFn = originalFn;
-    const wrapped = function(...args) {
-      if (this.signature > 0) {
-        this.signature++;
-        this.fire("render");
-        _View.destroyAllResources(this, false);
-        const lookup = asRecord(this);
-        const candidate = lookup[fnName];
-        const instanceFn = typeof candidate === "function" ? candidate : originalAsFn;
-        const fnToCall = instanceFn === wrapped ? originalAsFn : instanceFn;
-        return funcWithTry(fnToCall, args, this, noop);
-      }
-      return void 0;
-    };
-    proto[fnName] = wrapped;
-    proto[shortKey] = wrapped;
+}
+function mountCtx(frame, setup, params) {
+  const ctx = createCtx(frame);
+  setCurrentCtx(ctx);
+  let descriptor;
+  try {
+    descriptor = setup(ctx, params);
+  } finally {
+    setCurrentCtx(null);
+  }
+  ctx.setTemplate(descriptor.template);
+  ctx.setEvents(descriptor.events);
+  if (descriptor.assign) {
+    ctx.setAssign(descriptor.assign);
+  }
+  ctx.signature.value = 1;
+  frame.view = ctx;
+  registerEvents(ctx);
+  if (ctx.getTemplate()) {
+    ctx.render();
+  } else {
+    ctx.endUpdate();
   }
-  /**
-   * When two mixins define the same event method, merge them into
-   * a single function that calls both in sequence.
-   */
-  static processMixinsSameEvent(additional, exist) {
-    let temp;
-    if (exist.handlerList) {
-      temp = exist;
-    } else {
-      const merged = function(...e) {
-        funcWithTry(merged.handlerList ?? [], e, this, noop);
-      };
-      merged.handlerList = [exist];
-      merged.marker = 1;
-      temp = merged;
-    }
-    temp.handlerList = (temp.handlerList ?? []).concat(
-      additional.handlerList ?? [additional]
-    );
-    return temp;
+  return ctx;
+}
+function unmountCtx(ctx) {
+  for (let i = ctx.cleanups.length - 1; i >= 0; i--) {
+    const cleanup = ctx.cleanups[i];
+    funcWithTry(cleanup, [], null, noop);
   }
-  /**
-   * Merge an array of mixin objects into the view prototype.
-   */
-  static mergeMixins(mixins, viewClass, makes) {
-    const proto = asRecord(viewClass.prototype);
-    const temp = {};
-    for (const node of mixins) {
-      for (const p in node) {
-        if (!hasOwnProperty(node, p)) continue;
-        const fn = node[p];
-        if (typeof fn !== "function") continue;
-        const mixinFn = fn;
-        const exist = temp[p];
-        if (p === "make") {
-          makes.push(mixinFn);
-          continue;
-        }
-        if (VIEW_EVENT_METHOD_REGEXP.test(p)) {
-          if (exist) {
-            temp[p] = _View.processMixinsSameEvent(mixinFn, exist);
-          } else {
-            mixinFn.marker = 1;
-            temp[p] = mixinFn;
-          }
-        } else if (!exist) {
-          temp[p] = mixinFn;
-        }
-      }
-    }
-    for (const p in temp) {
-      if (!hasOwnProperty(proto, p)) {
-        proto[p] = temp[p];
-      }
-    }
+  ctx.cleanups.length = 0;
+  unregisterEvents(ctx);
+  destroyAllResources(ctx, true);
+  if (ctx.signature.value > 0) {
+    ctx.fire("destroy", void 0, true, true);
   }
-  /**
-   * Destroy a single resource entry.
-   */
-  static destroyResource(cache, key, callDestroy, oldEntity) {
-    const entry = cache[key];
-    if (!entry || entry.entity === oldEntity) return void 0;
-    const entity = entry.entity;
-    if (entity && typeof entity === "object") {
-      const destroyFn = entity["destroy"];
-      if (typeof destroyFn === "function" && callDestroy) {
-        funcWithTry(destroyFn, [], entity, noop);
-      }
-    }
-    Reflect.deleteProperty(cache, key);
-    return entity;
-  }
-  // ============================================================
-  // Static: extend and merge
-  // ============================================================
-  /**
-   * Extend View to create a new View subclass.
-   *
-   * Supports:
-   * - props.make: constructor-like init (called with initParams + {node, deep})
-   * - props.mixins: array of mixin objects
-   * - Event method patterns: `'name<click>'` etc.
-   */
-  static extend(props, statics) {
-    const definedProps = props ?? {};
-    const make = definedProps["make"];
-    const makes = [];
-    if (typeof make === "function") {
-      makes.push(make);
-    }
-    const ParentView = this;
-    const ChildView = class extends ParentView {
-      constructor(nodeId, ownerFrame, initParams, node, mixinCtors) {
-        super(nodeId, ownerFrame, initParams, node, []);
-        const instanceProps = this;
-        for (const key in definedProps) {
-          if (hasOwnProperty(definedProps, key) && key !== "make" && key !== "render") {
-            instanceProps[key] = definedProps[key];
-          }
-        }
-        this.id = nodeId;
-        this.owner = ownerFrame;
-        this.updater = new Updater(nodeId);
-        const params = [
-          initParams,
-          {
-            node,
-            deep: !this.template
-          }
-        ];
-        const concatCtors = makes.concat(mixinCtors || []);
-        if (concatCtors.length) {
-          funcWithTry(concatCtors, params, this, noop);
-        }
-      }
-    };
-    for (const key in definedProps) {
-      if (hasOwnProperty(definedProps, key) && key !== "make") {
-        Reflect.set(ChildView.prototype, key, definedProps[key]);
-      }
-    }
-    if (statics) {
-      for (const key in statics) {
-        if (hasOwnProperty(statics, key)) {
-          Reflect.set(ChildView, key, statics[key]);
-        }
+  EventDelegator.clearRangeEvents(ctx.id);
+  ctx.signature.value = 0;
+}
+
+// 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 ChildView;
-  }
-  /**
-   * Merge mixins into View prototype.
-   */
-  static merge(...mixins) {
-    const existingCtors = this.makes || [];
-    _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);
+    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);
+    });
   }
-  /**
-   * 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);
+  return loadPromise;
+}
+
+// src/view-registry.ts
+var viewSetupRegistry = {};
+function getViewClass(path) {
+  return viewSetupRegistry[path];
+}
+function registerViewClass(viewPath, setup) {
+  const parsed = parseUri(viewPath);
+  const path = parsed.path;
+  if (path) {
+    viewSetupRegistry[path] = setup;
   }
-};
+}
 
 // src/frame.ts
+var frameRegistry = /* @__PURE__ */ new Map();
 var rootFrame;
 var globalAlter;
-var MAX_FRAME_POOL = 64;
-var frameCache = [];
-var staticEmitter = new EventEmitter();
-var Frame = class _Frame extends EventEmitter {
-  /** Frame ID (same as owner DOM element ID) */
-  id;
-  /** Parent Frame ID */
-  _parentId = void 0;
-  get parentId() {
-    return this._parentId;
-  }
-  /** Children map: id -> id */
-  childrenMap = {};
-  /** Children count */
-  childrenCount = 0;
-  /** Ready count (children that have fired 'created') */
-  readyCount = 0;
-  /** Set of child frame IDs that have fired 'created' */
-  readyMap = /* @__PURE__ */ new Set();
-  /** View instance */
-  viewInstance;
-  /** Get view instance (read-only) */
-  get view() {
-    return this.viewInstance;
-  }
-  /** Invoke list for deferred method calls */
-  invokeList = [];
-  /** Signature for async operation tracking */
-  signature = 1;
-  /** Whether view has altered */
-  hasAltered = 0;
-  /** Whether view is destroyed */
-  destroyed = 0;
-  /** View path (v-lark attribute value) */
-  viewPath;
-  /** Original template before mount */
-  originalTemplate;
-  /** Hold fire created flag */
-  holdFireCreated = 0;
-  /** Children created flag */
-  childrenCreated = 0;
-  /** Children alter flag */
-  childrenAlter = 0;
-  constructor(id, parentId) {
-    super();
-    this.id = id;
-    if (parentId) {
-      this._parentId = parentId;
-    }
-    registerFrame(id, this);
-    const element = document.getElementById(id);
-    if (element) {
-      element.frame = this;
-      element.frameBound = 1;
-    }
-    _Frame.fire("add", { frame: this });
-  }
-  // ============================================================
-  // Instance methods
-  // ============================================================
-  /**
-   * Mount a view to this frame.
-   *
-   * Complete flow:
-   * 1. Parse viewPath, translate query params from parent
-   * 2. Unmount current view
-   * 3. Load View class (via require or provided ViewClass)
-   * 4. View_Prepare (scan event methods)
-   * 5. Create View instance
-   * 6. View_DelegateEvents (bind DOM events)
-   * 7. Call view.init()
-   * 8. If view has template, call render via Updater
-   * 9. If no template, call endUpdate directly
-   */
-  mountView(viewPath, viewInitParams) {
-    const node = document.getElementById(this.id);
-    const pId = this.parentId;
-    if (!this.hasAltered && node) {
-      this.hasAltered = 1;
-      this.originalTemplate = node.innerHTML;
-    }
-    this.unmountView();
-    this.destroyed = 0;
-    const parsed = parseUri(viewPath || "");
-    const viewClassName = parsed.path;
-    if (!node || !viewClassName) return;
-    this.viewPath = viewPath;
-    const params = parsed["params"];
-    translateQuery(pId || this.id, viewPath, params);
-    const initParams = { ...params };
-    if (viewInitParams) {
-      assign(initParams, viewInitParams);
-    }
-    const sign = this.signature;
-    const registered = getViewClass(viewClassName);
-    if (registered) {
-      this.doMountView(registered, initParams, node, sign);
-      return;
-    }
-    use(viewClassName, (ViewClass) => {
-      if (sign !== this.signature) return;
-      if (typeof ViewClass === "function") {
-        const ViewClassTyped = ViewClass;
-        registerViewClass(viewClassName, ViewClassTyped);
-        this.doMountView(ViewClassTyped, initParams, node, sign);
-      } else {
-        const error = new Error(`Cannot load view: ${viewClassName}`);
-        const errorHandler = config.error;
-        if (errorHandler) {
-          errorHandler(error);
-        }
+var staticEmitter = createEmitter();
+function isViewSetup(fn) {
+  return typeof fn === "function";
+}
+function createFrame(id, parentId) {
+  const emitter2 = createEmitter();
+  const invokeList = [];
+  const childrenMap = {};
+  const readyMap = /* @__PURE__ */ new Set();
+  let viewPath;
+  function getViewPath() {
+    return viewPath;
+  }
+  const frame = {
+    id,
+    getViewPath,
+    parentId,
+    view: void 0,
+    invokeList,
+    signature: 1,
+    destroyed: 0,
+    hasAltered: 0,
+    originalTemplate: void 0,
+    holdFireCreated: 0,
+    childrenCreated: 0,
+    childrenAlter: 0,
+    childrenMap,
+    childrenCount: 0,
+    readyCount: 0,
+    readyMap,
+    emitter: emitter2,
+    mountView(viewPathArg, viewInitParams) {
+      const node = document.getElementById(frame.id);
+      const pId = frame.parentId;
+      if (!frame.hasAltered && node) {
+        frame.hasAltered = 1;
+        frame.originalTemplate = node.innerHTML;
+      }
+      frame.unmountView();
+      frame.destroyed = 0;
+      const parsed = parseUri(viewPathArg || "");
+      const viewClassName = parsed.path;
+      if (!node || !viewClassName) return;
+      viewPath = viewPathArg;
+      const params = parsed.params;
+      translateQuery(pId ?? frame.id, viewPathArg, params);
+      const initParams = { ...params };
+      if (viewInitParams) {
+        assign(initParams, viewInitParams);
+      }
+      const sign = frame.signature;
+      const registered = getViewClass(viewClassName);
+      if (registered) {
+        doMountView(registered, initParams, node, sign);
+        return;
       }
-    });
-  }
-  /**
-   * Internal: actually mount the view after class is loaded.
-   */
-  doMountView(ViewClass, params, node, sign) {
-    if (sign !== this.signature) return;
-    const mixinConstructors = View.prepare(ViewClass);
-    const Constructor = ViewClass;
-    const view = new Constructor(
-      this.id,
-      this,
-      params,
-      node,
-      mixinConstructors
-    );
-    this.viewInstance = view;
-    view.signature = 1;
-    View.delegateEvents(view);
-    const initResult = funcWithTry(
-      view.init,
-      [params, { node, deep: !view.template }],
-      view,
-      noop
-    );
-    const nextSign = ++this.signature;
-    Promise.resolve(initResult).then(() => {
-      if (nextSign !== this.signature) return;
-      if (view.template) {
-        view.render();
-      } else {
-        this.hasAltered = 0;
-        if (!view.endUpdatePendingFlag) {
-          view.endUpdate();
+      use(viewClassName, (loadedModule) => {
+        if (sign !== frame.signature) return;
+        if (isViewSetup(loadedModule)) {
+          registerViewClass(viewClassName, loadedModule);
+          doMountView(loadedModule, initParams, node, sign);
+        } else {
+          const error = new Error(`Cannot load view: ${viewClassName}`);
+          const errorHandler = config.error;
+          if (errorHandler) {
+            errorHandler(error);
+          }
         }
+      });
+    },
+    unmountView() {
+      const currentView = frame.view;
+      frame.invokeList.length = 0;
+      if (!currentView) return;
+      if (!globalAlter) {
+        globalAlter = { id: frame.id };
+      }
+      frame.destroyed = 1;
+      frame.unmountZone();
+      notifyAlter(frame, globalAlter);
+      unmountCtx(currentView);
+      frame.view = void 0;
+      const node = document.getElementById(frame.id);
+      if (node && frame.originalTemplate) {
+        node.innerHTML = frame.originalTemplate;
+      }
+      globalAlter = void 0;
+      unmark(currentView);
+    },
+    mountFrame(frameId, viewPathArg, viewInitParams) {
+      notifyAlter(frame, { id: frameId });
+      let childFrame = frameRegistry.get(frameId);
+      if (!childFrame) {
+        if (!frame.childrenMap[frameId]) {
+          frame.childrenCount++;
+        }
+        frame.childrenMap[frameId] = frameId;
+        childFrame = createFrame(frameId, frame.id);
       }
-    });
-  }
-  /**
-   * Unmount current view.
-   */
-  unmountView() {
-    const view = this.view;
-    this.invokeList = [];
-    if (!view) return;
-    if (!globalAlter) {
-      globalAlter = { id: this.id };
-    }
-    this.destroyed = 1;
-    this.unmountZone();
-    notifyAlter(this, globalAlter);
-    if (view.signature > 0) {
-      view.fire("destroy", void 0, true, true);
-    }
-    EventDelegator.clearRangeEvents(this.id);
-    delete this["viewInstance"];
-    const node = document.getElementById(this.id);
-    if (node && this.originalTemplate) {
-      node.innerHTML = this.originalTemplate;
-    }
-    globalAlter = void 0;
-    unmark(view);
-  }
-  /**
-   * Mount a child frame.
-   */
-  mountFrame(frameId, viewPath, viewInitParams) {
-    notifyAlter(this, { id: frameId });
-    let childFrame = getFrame(frameId);
-    if (!childFrame) {
-      if (!this.childrenMap[frameId]) {
-        this.childrenCount++;
-      }
-      this.childrenMap[frameId] = frameId;
-      childFrame = frameCache.pop();
-      if (childFrame) {
-        reInitFrame(childFrame, frameId, this.id);
-      } else {
-        childFrame = new _Frame(frameId, this.id);
+      childFrame.mountView(viewPathArg, viewInitParams);
+      return childFrame;
+    },
+    unmountFrame(id2) {
+      const targetId = id2 ? frame.childrenMap[id2] : frame.id;
+      const targetFrame = frameRegistry.get(targetId);
+      if (!targetFrame) return;
+      const wasCreated = targetFrame.readyCount > 0;
+      const pId = targetFrame.parentId;
+      targetFrame.unmountView();
+      removeFrame(targetId, wasCreated);
+      const parent = frameRegistry.get(pId ?? "");
+      if (parent && parent.childrenMap[targetId]) {
+        Reflect.deleteProperty(parent.childrenMap, targetId);
+        parent.childrenCount--;
+        notifyCreated(parent);
       }
-    }
-    childFrame.mountView(viewPath, viewInitParams);
-    return childFrame;
-  }
-  /**
-   * Unmount a child frame.
-   */
-  unmountFrame(id) {
-    const targetId = id ? this.childrenMap[id] : this.id;
-    const frame = getFrame(targetId);
-    if (!frame) return;
-    const wasCreated = frame.readyCount > 0;
-    const pId = frame.parentId;
-    frame.unmountView();
-    removeFrame2(targetId, wasCreated);
-    reInitFrameForCache(frame);
-    if (frameCache.length < MAX_FRAME_POOL) {
-      frameCache.push(frame);
-    }
-    const parent = getFrame(pId || "");
-    if (parent && parent.childrenMap[targetId]) {
-      Reflect.deleteProperty(parent.childrenMap, targetId);
-      parent.childrenCount--;
-      notifyCreated(parent);
-    }
-  }
-  /**
-   * Mount all views in a zone.
-   */
-  mountZone(zoneId) {
-    const targetZone = zoneId || this.id;
-    this.holdFireCreated = 1;
-    const rootEl = document.getElementById(targetZone);
-    if (!rootEl) return;
-    const viewElements = rootEl.querySelectorAll(`[${LARK_VIEW}]`);
-    const frames = [];
-    viewElements.forEach((el) => {
-      if (!(el instanceof HTMLElement)) return;
-      if (htmlElIsBound(el)) return;
-      const elId = ensureElementId(el, "frame_");
-      el.frameBound = 1;
-      const viewPath = getAttribute(el, LARK_VIEW);
-      frames.push([elId, viewPath]);
-    });
-    for (const [frameId, viewPath] of frames) {
-      this.mountFrame(frameId, viewPath);
-    }
-    this.holdFireCreated = 0;
-    notifyCreated(this);
-  }
-  /**
-   * Unmount all views in a zone.
-   */
-  unmountZone(zoneId) {
-    for (const childId in this.childrenMap) {
-      if (hasOwnProperty(this.childrenMap, childId)) {
-        if (!zoneId || childId !== zoneId) {
-          this.unmountFrame(childId);
+    },
+    mountZone(zoneId) {
+      const targetZone = zoneId ?? frame.id;
+      frame.holdFireCreated = 1;
+      const rootEl = document.getElementById(targetZone);
+      if (!rootEl) return;
+      const viewElements = rootEl.querySelectorAll(`[${LARK_VIEW}]`);
+      const frames = [];
+      viewElements.forEach((el) => {
+        if (!(el instanceof HTMLElement)) return;
+        if (htmlElIsBound(el)) return;
+        const elId = ensureElementId(el, "frame_");
+        Reflect.set(el, "frameBound", 1);
+        const viewPathArg = getAttribute(el, LARK_VIEW);
+        if (viewPathArg) {
+          frames.push([elId, viewPathArg]);
         }
+      });
+      for (const [frameId, viewPathArg] of frames) {
+        frame.mountFrame(frameId, viewPathArg);
       }
-    }
-    notifyCreated(this);
-  }
-  /**
-   * Get all child frame IDs.
-   */
-  children() {
-    const result = [];
-    for (const id in this.childrenMap) {
-      if (hasOwnProperty(this.childrenMap, id)) {
-        result.push(id);
-      }
-    }
-    return result;
-  }
-  /**
-   * Get parent frame at given level.
-   * @param level - How many levels up (default 1)
-   */
-  parent(level = 1) {
-    let frame = void 0;
-    let currentPid = this.parentId;
-    let n = level >>> 0 || 1;
-    while (currentPid && n--) {
-      frame = getFrame(currentPid);
-      currentPid = frame?.parentId;
-    }
-    return frame;
-  }
-  /**
-   * Invoke a method on the view.
-   */
-  invoke(name, args) {
-    let result;
-    const view = this.view;
-    if (view && view.rendered) {
-      const fn = Reflect.get(view, name);
-      if (typeof fn === "function") {
-        result = funcWithTry(fn, args || [], view, noop);
+      frame.holdFireCreated = 0;
+      notifyCreated(frame);
+    },
+    unmountZone(zoneId) {
+      for (const childId in frame.childrenMap) {
+        if (hasOwnProperty(frame.childrenMap, childId)) {
+          if (!zoneId || childId !== zoneId) {
+            frame.unmountFrame(childId);
+          }
+        }
       }
-    } else {
-      const key = SPLITTER + name;
-      let existingEntry;
-      for (const entry of this.invokeList) {
-        if (entry.key === key) {
-          existingEntry = entry;
-          break;
+      notifyCreated(frame);
+    },
+    parent(level = 1) {
+      let result = void 0;
+      let currentPid = frame.parentId;
+      let n = level >>> 0 || 1;
+      while (currentPid && n--) {
+        result = frameRegistry.get(currentPid);
+        currentPid = result?.parentId;
+      }
+      return result;
+    },
+    invoke(name, args) {
+      let result;
+      const currentView = frame.view;
+      if (currentView && currentView.rendered.value) {
+        const fn = Reflect.get(currentView, name);
+        if (typeof fn === "function") {
+          result = funcWithTry(fn, args ?? [], currentView, noop);
+        }
+      } else {
+        const key = SPLITTER + name;
+        let existingEntry;
+        for (const entry of frame.invokeList) {
+          if (entry.key === key) {
+            existingEntry = entry;
+            break;
+          }
         }
+        if (existingEntry) {
+          existingEntry.removed = args === existingEntry.args;
+        }
+        const newEntry = {
+          name,
+          args: args ?? [],
+          key
+        };
+        frame.invokeList.push(newEntry);
       }
-      if (existingEntry) {
-        existingEntry.removed = args === existingEntry.args;
+      return result;
+    },
+    children() {
+      const result = [];
+      for (const id2 in frame.childrenMap) {
+        if (hasOwnProperty(frame.childrenMap, id2)) {
+          result.push(id2);
+        }
       }
-      const newEntry = {
-        name,
-        args: args || [],
-        key
-      };
-      this.invokeList.push(newEntry);
+      return result;
+    },
+    on(event, handler) {
+      emitter2.on(event, handler);
+      return frame;
+    },
+    off(event, handler) {
+      emitter2.off(event, handler);
+      return frame;
+    },
+    fire(event, data) {
+      emitter2.fire(event, data);
+      return frame;
     }
-    return result;
-  }
-  /**
-   * Type-safe variant of `invoke`.
-   *
-   * `invoke()` accepts any string and any args, which silently hides
-   * mismatched call sites when a method gets renamed. `invokeTyped` carries
-   * the view's method signature through TypeScript so the compiler catches
-   * those mistakes:
-   *
-   * ```ts
-   * type Home = View & { loadData(id: string): Promise<void> };
-   * frame.invokeTyped<Home, "loadData">("loadData", ["user-1"]);
-   * ```
-   *
-   * Behavior is identical to `invoke` at runtime — same defer / direct-call
-   * paths — so it's a drop-in safer overload.
-   */
-  invokeTyped(name, args) {
-    return this.invoke(name, args);
-  }
-  // ============================================================
-  // Static methods
-  // ============================================================
+  };
+  frameRegistry.set(id, frame);
+  const element = document.getElementById(id);
+  if (element) {
+    Reflect.set(element, "frame", frame);
+    Reflect.set(element, "frameBound", 1);
+  }
+  staticEmitter.fire("add", { frame });
+  return frame;
+}
+function doMountView(setup, params, node, sign) {
+  const frameId = node.id;
+  const frame = frameRegistry.get(frameId);
+  if (!frame) return;
+  if (sign !== frame.signature) return;
+  const ctx = mountCtx(frame, setup, params);
+  frame.view = ctx;
+  runInvokes(frame);
+}
+var Frame = {
   /** Get frame by ID */
-  static get(id) {
-    return getFrame(id);
-  }
+  get(id) {
+    return frameRegistry.get(id);
+  },
   /** Get all frames */
-  static getAll() {
-    return getAllFrames();
-  }
+  getAll() {
+    return frameRegistry;
+  },
   /**
-   * Returns the existing root frame, or `undefined` if none has been created.
-   * Pure getter — never creates a Frame, never touches the DOM.
-   *
-   * Use `Frame.createRoot(id)` to create the root explicitly during framework
-   * boot. For Micro-Frontend hosts that own multiple independent containers,
-   * use `new Frame(containerId)` directly so each MF mount has its own root.
+   * Returns the existing root frame, or undefined if none has been created.
    */
-  static getRoot() {
+  getRoot() {
     return rootFrame;
-  }
+  },
   /**
-   * Create (or return) the singleton root frame for this app.
-   *
-   * Idempotent: subsequent calls always return the original root regardless
-   * of `rootId` — so passing a different id later is silently ignored.
-   * `Framework.boot()` is the canonical caller; user code rarely needs this.
+   * Create (or return) the singleton root frame.
+   * Idempotent: subsequent calls always return the original root.
    */
-  static createRoot(rootId) {
+  createRoot(rootId) {
     if (!rootFrame) {
-      rootId = rootId || "root";
-      let rootElement = document.getElementById(rootId);
+      const id = rootId ?? "root";
+      let rootElement = document.getElementById(id);
       if (!rootElement) {
         rootElement = document.body;
-        rootElement.id = rootId;
+        rootElement.id = id;
       }
-      rootFrame = new _Frame(rootId);
+      rootFrame = createFrame(id);
     }
     return rootFrame;
-  }
+  },
   /** Bind event listener (static) */
-  static on(event, handler) {
+  on(event, handler) {
     staticEmitter.on(event, handler);
-    return _Frame;
-  }
+    return Frame;
+  },
   /** Unbind event listener (static) */
-  static off(event, handler) {
+  off(event, handler) {
     staticEmitter.off(event, handler);
-    return _Frame;
-  }
+    return Frame;
+  },
   /** Fire event (static) */
-  static fire(event, data) {
+  fire(event, data) {
     staticEmitter.fire(event, data);
   }
 };
 function htmlElIsBound(element) {
-  return !!element.frameBound;
+  return !!Reflect.get(element, "frameBound");
 }
-function removeFrame2(id, wasCreated) {
-  const frameInstance = getFrame(id);
+function removeFrame(id, wasCreated) {
+  const frameInstance = frameRegistry.get(id);
   if (!frameInstance) return;
-  removeFrame(id);
-  Frame.fire("remove", { frame: frameInstance, fcc: wasCreated });
+  frameRegistry.delete(id);
+  staticEmitter.fire("remove", { frame: frameInstance, fcc: wasCreated });
   const element = document.getElementById(id);
   if (element) {
-    element.frameBound = 0;
+    Reflect.set(element, "frameBound", 0);
     Reflect.deleteProperty(element, "frame");
   }
 }
 function notifyCreated(frameInstance) {
-  if (!frameInstance["childrenCreated"] && !frameInstance["holdFireCreated"] && frameInstance["childrenCount"] === frameInstance["readyCount"]) {
-    if (!frameInstance["childrenCreated"]) {
-      frameInstance["childrenCreated"] = 1;
-      frameInstance["childrenAlter"] = 0;
-      frameInstance.fire("created");
-    }
+  if (!frameInstance.childrenCreated && !frameInstance.holdFireCreated && frameInstance.childrenCount === frameInstance.readyCount) {
+    frameInstance.childrenCreated = 1;
+    frameInstance.childrenAlter = 0;
+    frameInstance.emitter.fire("created");
     const pId = frameInstance.parentId;
     if (pId) {
-      const parent = getFrame(pId);
+      const parent = frameRegistry.get(pId);
       if (parent && !parent.readyMap.has(frameInstance.id)) {
         parent.readyMap.add(frameInstance.id);
         parent.readyCount++;
@@ -3195,13 +2632,13 @@ function notifyCreated(frameInstance) {
   }
 }
 function notifyAlter(frameInstance, data) {
-  if (!frameInstance["childrenAlter"] && frameInstance["childrenCreated"]) {
-    frameInstance["childrenCreated"] = 0;
-    frameInstance["childrenAlter"] = 1;
-    frameInstance.fire("alter", data);
+  if (!frameInstance.childrenAlter && frameInstance.childrenCreated) {
+    frameInstance.childrenCreated = 0;
+    frameInstance.childrenAlter = 1;
+    frameInstance.emitter.fire("alter", data);
     const pId = frameInstance.parentId;
     if (pId) {
-      const parent = getFrame(pId);
+      const parent = frameRegistry.get(pId);
       if (parent && parent.readyMap.has(frameInstance.id)) {
         parent.readyCount--;
         parent.readyMap.delete(frameInstance.id);
@@ -3210,35 +2647,24 @@ function notifyAlter(frameInstance, data) {
     }
   }
 }
-function reInitFrame(frame, id, parentId) {
-  Reflect.set(frame, "id", id);
-  frame["_parentId"] = parentId;
-  frame["childrenMap"] = {};
-  frame["childrenCount"] = 0;
-  frame["readyCount"] = 0;
-  frame["signature"] = 1;
-  frame["readyMap"] = /* @__PURE__ */ new Set();
-  frame["invokeList"] = [];
-  registerFrame(id, frame);
-}
-function reInitFrameForCache(frame) {
-  Reflect.set(frame, "id", "");
-  frame["_parentId"] = void 0;
-  frame["childrenMap"] = {};
-  frame["readyMap"] = /* @__PURE__ */ new Set();
-}
 function translateQuery(pId, src, params) {
-  const parentFrame = getFrame(pId);
+  const parentFrame = frameRegistry.get(pId);
   const parentView = parentFrame?.view;
   if (!parentView) return;
   const parentRefData = parentView.updater.refData;
   if (!parentRefData) return;
   if (src.indexOf(SPLITTER) > 0) {
     translateData(parentRefData, params);
-    const paramsRec = params;
-    const splitterValue = paramsRec[SPLITTER];
-    if (splitterValue && typeof splitterValue === "object") {
-      assign(params, splitterValue);
+    const splitterValue = Reflect.get(params, SPLITTER);
+    if (isRecord(splitterValue)) {
+      for (const k in splitterValue) {
+        if (hasOwnProperty(splitterValue, k)) {
+          const v = splitterValue[k];
+          if (typeof v === "string") {
+            params[k] = v;
+          }
+        }
+      }
       Reflect.deleteProperty(params, SPLITTER);
     }
   }
@@ -3253,10 +2679,10 @@ var FrameDevtoolBridge = {
   MSG_TREE_DELTA: "LARK_DEVTOOL_TREE_DELTA"
 };
 function serializeView(view) {
-  const evtMap = view.eventObjectMap;
+  const evtMap = {};
   const eventMethodKeys = evtMap ? Object.keys(evtMap) : [];
   const resourceKeys = view.resources ? Object.keys(view.resources) : [];
-  const hasAssign = typeof view["assign"] === "function";
+  const hasAssign = typeof view.getAssign() === "function";
   let updaterData = null;
   try {
     const ref = view.updater?.refData;
@@ -3272,14 +2698,14 @@ function serializeView(view) {
   return {
     id: view.id,
     rendered: !!view.rendered,
-    signature: view.signature,
-    observedStateKeys: view.observedStateKeys ?? null,
+    signature: view.signature.value,
+    observedStateKeys: view.getObservedStateKeys() ?? null,
     locationObserved: {
       flag: view.locationObserved.flag,
       keys: view.locationObserved.keys,
       observePath: view.locationObserved.observePath
     },
-    hasTemplate: !!view.template,
+    hasTemplate: !!view.getTemplate(),
     eventMethodKeys,
     resourceKeys,
     hasAssign,
@@ -3300,7 +2726,7 @@ function serializeFrame(frameId) {
   return {
     id: frame.id,
     parentId: frame.parentId ?? null,
-    viewPath: frame.viewPath ?? null,
+    viewPath: frame.getViewPath() ?? null,
     childrenCount: frame.childrenCount,
     readyCount: frame.readyCount,
     childrenCreated: frame.childrenCreated,
@@ -3345,10 +2771,7 @@ function installFrameDevtoolBridge() {
     if (type === FrameDevtoolBridge.MSG_PING) {
       const source = event.source;
       if (source) {
-        source.postMessage(
-          { type: FrameDevtoolBridge.MSG_PONG },
-          { targetOrigin: "*" }
-        );
+        source.postMessage({ type: FrameDevtoolBridge.MSG_PONG }, { targetOrigin: "*" });
       }
       return;
     }
@@ -3376,10 +2799,7 @@ function pushTreeUpdate() {
   const treeJson = JSON.stringify(tree);
   if (treeJson !== lastTreeJson) {
     lastTreeJson = treeJson;
-    window.parent.postMessage(
-      { type: FrameDevtoolBridge.MSG_TREE_DELTA, data: tree },
-      "*"
-    );
+    window.parent.postMessage({ type: FrameDevtoolBridge.MSG_TREE_DELTA, data: tree }, "*");
   }
 }
 // Annotate the CommonJS export names for ESM import in node: