weifuwu 0.33.11 → 0.35.0

package/dist/client/index.js

@@ -1,809 +1,674 @@
-// src/client/signal.ts
-var currentEffect = null;
-var currentDeps = null;
-var _batchDepth = 0;
-var _pendingBatch = /* @__PURE__ */ new Set();
-var Signal = class {
-  #value;
-  #listeners = /* @__PURE__ */ new Set();
-  constructor(value) {
-    this.#value = value;
-  }
-  get value() {
-    if (currentEffect) {
-      this.#listeners.add(currentEffect);
-      currentDeps?.add(this);
-    }
-    return this.#value;
-  }
-  set value(v) {
-    if (v !== this.#value) {
-      this.#value = v;
-      this.#notify();
-    }
-  }
-  /** @internal 移除监听器（由 effect dispose 调用） */
-  _removeListener(fn) {
-    this.#listeners.delete(fn);
-  }
-  /**
-   * 可变更新 — 原地修改信号值并触发通知。
-   *
-   * 适用于数组/对象等引用类型：无需创建新引用即可触发更新。
-   *
-   * ```ts
-   * const items = signal([1, 2, 3])
-   * items.mutate(arr => arr.push(4))  // 数组原地修改
-   * // items.value === [1, 2, 3, 4]
-   * ```
-   */
-  mutate(fn) {
-    fn(this.#value);
-    this.#notify();
-  }
-  /** 通知所有监听器 — 批量模式时积攒，否则立即执行 */
-  #notify() {
-    if (_batchDepth > 0) {
-      for (const fn of this.#listeners) _pendingBatch.add(fn);
-    } else {
-      const fns = [...this.#listeners];
-      for (const fn of fns) fn();
-    }
-  }
-};
-function signal(initial) {
-  return new Signal(initial);
+// src/client/vnode.ts
+var Fragment = /* @__PURE__ */ Symbol("Fragment");
+function jsx(type, props, key) {
+  return {
+    type,
+    props: normalizeProps(props),
+    key: key ?? void 0
+  };
 }
-function isSignal(value) {
-  return value instanceof Signal;
+var jsxs = jsx;
+function jsxDEV(type, props, key) {
+  return jsx(type, props, key);
 }
-function effect(fn) {
-  const deps = /* @__PURE__ */ new Set();
-  const run = () => {
-    for (const dep of deps) dep._removeListener(run);
-    deps.clear();
-    const prevEffect = currentEffect;
-    const prevDeps = currentDeps;
-    currentEffect = run;
-    currentDeps = deps;
-    try {
-      fn();
-    } finally {
-      currentEffect = prevEffect;
-      currentDeps = prevDeps;
-    }
-  };
-  run();
-  return () => {
-    for (const dep of deps) dep._removeListener(run);
-    deps.clear();
-  };
+var h = jsx;
+function normalizeProps(props) {
+  if (!props) return {};
+  const result = {};
+  for (const key of Object.keys(props)) {
+    if (key === "key") continue;
+    result[key] = props[key];
+  }
+  return result;
 }
-function computed(fn) {
-  const s = signal(void 0);
-  effect(() => {
-    s.value = fn();
-  });
-  return s;
+
+// src/client/render.ts
+function render(input, ctx) {
+  return renderValue(input, ctx);
+}
+function renderValue(v, ctx) {
+  if (v == null || typeof v === "boolean") return document.createTextNode("");
+  if (typeof v === "string" || typeof v === "number") return document.createTextNode(String(v));
+  if (Array.isArray(v)) return renderArray(v, ctx);
+  const vnode = v;
+  if (vnode.type === Fragment) {
+    const frag = document.createDocumentFragment();
+    forEach(vnode.props?.children, (child) => frag.appendChild(renderValue(child, ctx)));
+    return frag;
+  }
+  if (typeof vnode.type === "function") {
+    return renderComponent(vnode.type, vnode.props, vnode, ctx);
+  }
+  const el = document.createElement(vnode.type);
+  vnode.el = el;
+  for (const [key, value] of Object.entries(vnode.props ?? {})) {
+    if (key === "children" || key === "key" || key === "ref") continue;
+    setProp(el, key, value);
+  }
+  const flatChildren = flattenChildren(vnode.props?.children);
+  for (const child of flatChildren) {
+    el.appendChild(renderValue(child, ctx));
+  }
+  if (vnode.props?.ref) {
+    queueMicrotask(() => vnode.props.ref(el));
+  }
+  return el;
 }
-function batch(fn) {
-  _batchDepth++;
+function renderComponent(Comp, props, vnode, ctx) {
+  const prev$ = vnode._$;
+  if (!prev$) vnode._$ = {};
+  ctx.ui = ctx.ui ?? {};
+  ctx.ui.ready = !!prev$;
+  let childVNode;
   try {
-    fn();
-  } finally {
-    _batchDepth--;
-    if (_batchDepth === 0 && _pendingBatch.size > 0) {
-      const fns = [..._pendingBatch];
-      _pendingBatch.clear();
-      for (const fn2 of fns) fn2();
+    childVNode = Comp(props, ctx);
+  } catch (e) {
+    const errHandler = ctx.ui?._errorHandler;
+    if (errHandler) {
+      errHandler(e);
+      childVNode = null;
+    } else {
+      console.error("Component render error:", e);
+      childVNode = null;
     }
   }
-}
-function untrack(fn) {
-  const prevEffect = currentEffect;
-  const prevDeps = currentDeps;
-  currentEffect = null;
-  currentDeps = null;
-  try {
-    return fn();
-  } finally {
-    currentEffect = prevEffect;
-    currentDeps = prevDeps;
+  if (childVNode == null) {
+    vnode._child = null;
+    return document.createTextNode("");
   }
+  vnode._child = childVNode;
+  return renderValue(childVNode, ctx);
 }
-
-// src/client/jsx-runtime.ts
-var currentCtx = null;
-function setCtx(ctx) {
-  currentCtx = ctx;
-}
-function onMount(fn) {
-  if (_pendingMountQueue) _pendingMountQueue.push(fn);
+function renderArray(arr, ctx) {
+  const frag = document.createDocumentFragment();
+  for (const item of arr) frag.appendChild(renderValue(item, ctx));
+  return frag;
 }
-function onCleanup(fn) {
-  if (_pendingCleanupQueue) _pendingCleanupQueue.push(fn);
-}
-var _pendingMountQueue = null;
-var _pendingCleanupQueue = null;
-var _entries = /* @__PURE__ */ new Map();
-function _ensure(el) {
-  let entry = _entries.get(el);
-  if (entry) return entry;
-  entry = {
-    mounted: document.contains(el),
-    observer: null,
-    mountFns: [],
-    disposeFns: []
-  };
-  _entries.set(el, entry);
-  const obs = new MutationObserver(() => {
-    const now = document.contains(el);
-    if (now && !entry.mounted) {
-      entry.mounted = true;
-      const fns = entry.mountFns.slice();
-      entry.mountFns = [];
-      for (const fn of fns) {
-        const dispose = fn();
-        if (typeof dispose === "function") {
-          entry.disposeFns.push(dispose);
-        }
-      }
-    } else if (!now && entry.mounted) {
-      entry.mounted = false;
-      for (const fn of entry.disposeFns) fn();
-      entry.disposeFns = [];
-      entry.mountFns = [];
-      obs.disconnect();
-      _entries.delete(el);
-    }
-  });
-  obs.observe(document.body, { childList: true, subtree: true });
-  entry.observer = obs;
-  return entry;
+function forEach(children, fn) {
+  if (children == null) return;
+  if (Array.isArray(children)) {
+    children.forEach(fn);
+    return;
+  }
+  fn(children);
 }
-function _onMountElement(el, fn) {
-  const entry = _ensure(el);
-  if (entry.mounted) {
-    const dispose = fn();
-    if (typeof dispose === "function") {
-      entry.disposeFns.push(dispose);
+function flattenChildren(children) {
+  if (children == null) return [];
+  if (!Array.isArray(children)) return [children];
+  const result = [];
+  for (const child of children) {
+    if (Array.isArray(child)) {
+      result.push(...child);
+    } else {
+      result.push(child);
     }
-  } else {
-    entry.mountFns.push(fn);
   }
-}
-function wrap(tagName, setup) {
-  return (props, ctx) => {
-    const el = document.createElement(tagName);
-    _onMountElement(el, () => setup(el, props, ctx));
-    return el;
-  };
-}
-function _trackEffect(el, dispose) {
-  const entry = _ensure(el);
-  entry.disposeFns.push(dispose);
+  return result;
 }
 function setProp(el, key, value) {
   if (key === "class" || key === "className") {
-    if (isSignal(value)) {
-      _trackEffect(el, effect(() => {
-        el.className = String(value.value);
-      }));
-    } else {
-      el.className = String(value ?? "");
-    }
+    el.className = String(value ?? "");
   } else if (key === "style" && typeof value === "object" && value !== null) {
     Object.assign(el.style, value);
   } else if (key.startsWith("on") && typeof value === "function") {
     el.addEventListener(key.slice(2).toLowerCase(), value);
-  } else if (key === "ref" && typeof value === "function") {
-    value(el);
-  } else if (isSignal(value)) {
-    _trackEffect(el, effect(() => {
-      const v = value.value;
-      if (key === "value" || key === "checked") {
-        el[key] = v;
-      } else if (v == null || v === false) {
-        el.removeAttribute(key);
-      } else if (v === true) {
-        el.setAttribute(key, "");
-      } else {
-        el.setAttribute(key, String(v));
-      }
-    }));
+  } else if (key === "value" && (el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement)) {
+    ;
+    el.value = String(value ?? "");
+  } else if (value === true) {
+    el.setAttribute(key, "");
   } else if (value != null && value !== false) {
-    if (value === true) el.setAttribute(key, "");
-    else if (key === "value" || key === "checked") el[key] = value;
-    else el.setAttribute(key, String(value));
+    el.setAttribute(key, String(value));
   }
 }
-function _closestElement(node) {
-  if (node instanceof Element) return node;
-  if (node instanceof DocumentFragment) {
+function patchValue(parent, oldNode, oldInput, newInput, ctx) {
+  if (oldInput == null) {
+    if (newInput == null) return null;
+    const node = renderValue(newInput, ctx);
+    if (oldNode && oldNode.parentNode) {
+      oldNode.parentNode.insertBefore(node, oldNode);
+    } else {
+      parent.appendChild(node);
+    }
+    return node;
+  }
+  if (newInput == null) {
+    if (oldNode) {
+      callRef(oldInput, null);
+      oldNode.remove();
+    }
     return null;
   }
-  let parent = node.parentNode;
-  while (parent) {
-    if (parent instanceof Element) return parent;
-    parent = parent.parentNode;
+  const oldType = typeOf(oldInput);
+  const newType = typeOf(newInput);
+  if (oldType !== newType) {
+    callRef(oldInput, null);
+    const node = renderValue(newInput, ctx);
+    if (oldNode?.parentNode) {
+      oldNode.parentNode.replaceChild(node, oldNode);
+    }
+    return node;
+  }
+  if (newType === "text") {
+    if (oldNode && oldNode.textContent !== String(newInput)) {
+      oldNode.textContent = String(newInput);
+    }
+    return oldNode;
+  }
+  const newV = newInput;
+  const oldV = oldInput;
+  if (typeof newV.type === "function") {
+    const comp = newV.type;
+    if (oldV._$) newV._$ = oldV._$;
+    ctx.ui = ctx.ui ?? {};
+    ctx.ui.ready = !!newV._$;
+    const childNew = comp(newV.props, ctx);
+    newV._child = childNew;
+    return patchValue(parent, oldNode, oldV._child, childNew, ctx);
+  }
+  if (newV.type === Fragment) {
+    patchChildren(parent, oldV, newV, ctx);
+    return oldNode;
+  }
+  if (typeof newV.type === "string") {
+    if (oldNode && oldNode.nodeType === 1) {
+      patchProps(oldNode, oldV.props, newV.props);
+      patchChildren(oldNode, oldV, newV, ctx);
+    } else if (oldNode) {
+      callRef(oldInput, null);
+      const node = renderValue(newInput, ctx);
+      oldNode.parentNode?.replaceChild(node, oldNode);
+      return node;
+    }
+    return oldNode;
+  }
+  if (Array.isArray(newInput)) {
+    const oldArr = Array.isArray(oldInput) ? oldInput : [];
+    patchSimpleChildren(parent, oldArr, newInput, ctx);
+    return oldNode;
+  }
+  return oldNode;
+}
+function typeOf(input) {
+  if (input == null || typeof input === "boolean") return "null";
+  if (typeof input === "string" || typeof input === "number") return "text";
+  if (Array.isArray(input)) return "array";
+  const v = input;
+  if (typeof v.type === "function") return `fn:${v.type.name || "anon"}`;
+  if (v.type === Fragment) return "fragment";
+  if (typeof v.type === "string") return "tag:" + v.type;
+  return "unknown";
+}
+function patchProps(el, oldProps, newProps) {
+  const oldKeys = oldProps ? Object.keys(oldProps).filter((k) => k !== "children" && k !== "key" && k !== "ref") : [];
+  const newKeys = newProps ? Object.keys(newProps).filter((k) => k !== "children" && k !== "key" && k !== "ref") : [];
+  for (const key of oldKeys) {
+    if (!newKeys.includes(key)) {
+      if (key === "value" && (el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement)) {
+        ;
+        el.value = "";
+      } else {
+        el.removeAttribute(key === "className" ? "class" : key);
+      }
+    }
+  }
+  for (const key of newKeys) {
+    const oldVal = oldProps?.[key];
+    const newVal = newProps?.[key];
+    if (newVal !== oldVal) {
+      if (key === "class" || key === "className") {
+        el.className = String(newVal ?? "");
+      } else if (key === "style" && typeof newVal === "object") {
+        Object.assign(el.style, newVal);
+      } else if (key.startsWith("on") && typeof newVal === "function") {
+        const eventName = key.slice(2).toLowerCase();
+        if (typeof oldVal === "function") el.removeEventListener(eventName, oldVal);
+        el.addEventListener(eventName, newVal);
+      } else if (key === "value" && (el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement)) {
+        ;
+        el.value = String(newVal ?? "");
+      } else if (newVal === true) {
+        el.setAttribute(key, "");
+      } else if (newVal != null && newVal !== false) {
+        el.setAttribute(key, String(newVal));
+      } else {
+        if (key === "value" && (el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement)) {
+          ;
+          el.value = "";
+        } else {
+          el.removeAttribute(key);
+        }
+      }
+    }
   }
-  return null;
 }
-function appendChild(parent, child) {
-  if (child == null || child === false || child === true) return;
-  if (Array.isArray(child)) {
-    child.forEach((c) => appendChild(parent, c));
-    return;
+function getKey(input) {
+  if (input == null || typeof input !== "object") return void 0;
+  return input.key;
+}
+function patchChildren(parent, oldVNode, newVNode, ctx) {
+  const oldChildren = normalize(oldVNode.props?.children);
+  const newChildren = normalize(newVNode.props?.children);
+  const hasKey = newChildren.some((c) => getKey(c) !== void 0);
+  if (hasKey) {
+    patchKeyedChildren(parent, oldChildren, newChildren, ctx);
+  } else {
+    patchSimpleChildren(parent, oldChildren, newChildren, ctx);
   }
-  if (child instanceof Node) {
-    parent.appendChild(child);
-    return;
+}
+function normalize(children) {
+  if (children == null) return [];
+  if (!Array.isArray(children)) return [children];
+  const result = [];
+  for (const child of children) {
+    if (Array.isArray(child)) {
+      result.push(...child);
+    } else {
+      result.push(child);
+    }
   }
-  if (isSignal(child)) {
-    const text = document.createTextNode("");
-    const parentEl = parent instanceof Element ? parent : _closestElement(parent);
-    if (parentEl) {
-      _trackEffect(parentEl, effect(() => {
-        text.textContent = String(child.value);
-      }));
+  return result;
+}
+function patchSimpleChildren(parent, oldChildren, newChildren, ctx) {
+  const max = Math.max(oldChildren.length, newChildren.length);
+  for (let i = 0; i < max; i++) {
+    const oldChild = oldChildren[i];
+    const newChild = newChildren[i];
+    const existingNode = parent.childNodes[i] || null;
+    if (oldChild === void 0 && newChild !== void 0) {
+      const node = renderValue(newChild, ctx);
+      parent.appendChild(node);
+    } else if (newChild === void 0) {
+      if (existingNode) {
+        callRef(oldChild, null);
+        existingNode.remove();
+      }
     } else {
-      const anchor = document.createElement("div");
-      anchor.style.display = "contents";
-      _trackEffect(anchor, effect(() => {
-        text.textContent = String(child.value);
-      }));
-      anchor.appendChild(text);
-      parent.appendChild(anchor);
-      return;
+      patchValue(parent, existingNode, oldChild, newChild, ctx);
     }
-    parent.appendChild(text);
-    return;
   }
-  parent.appendChild(document.createTextNode(String(child)));
 }
-function jsx(type, props, ...children) {
-  if (typeof type === "function") {
-    const merged = children.length > 0 ? { ...props, children } : props;
-    const prevMount = _pendingMountQueue;
-    const prevCleanup = _pendingCleanupQueue;
-    _pendingMountQueue = [];
-    _pendingCleanupQueue = [];
-    let result = document.createDocumentFragment();
-    try {
-      result = type(merged, currentCtx) ?? document.createDocumentFragment();
-    } finally {
-      if (_pendingMountQueue.length > 0 || _pendingCleanupQueue.length > 0) {
-        let targetEl = null;
-        if (result instanceof Element) {
-          targetEl = result;
-        } else if (result instanceof DocumentFragment && result.firstElementChild) {
-          targetEl = result.firstElementChild;
-        }
-        if (targetEl) {
-          const entry = _ensure(targetEl);
-          for (const fn of _pendingMountQueue) {
-            if (entry.mounted) {
-              const dispose = fn();
-              if (typeof dispose === "function") entry.disposeFns.push(dispose);
-            } else {
-              entry.mountFns.push(fn);
-            }
-          }
-          for (const fn of _pendingCleanupQueue) {
-            entry.disposeFns.push(fn);
-          }
-        }
+function patchKeyedChildren(parent, oldChildren, newChildren, ctx) {
+  const oldKeyMap = /* @__PURE__ */ new Map();
+  for (let i = 0; i < oldChildren.length; i++) {
+    const key = getKey(oldChildren[i]);
+    if (key !== void 0) {
+      oldKeyMap.set(key, { vnode: oldChildren[i], node: parent.childNodes[i] || null });
+    }
+  }
+  const newKeys = newChildren.map((c) => getKey(c));
+  for (const key of oldKeyMap.keys()) {
+    if (!newKeys.includes(key)) {
+      const entry = oldKeyMap.get(key);
+      callRef(entry.vnode, null);
+      entry.node?.remove();
+      oldKeyMap.delete(key);
+    }
+  }
+  for (let i = oldChildren.length - 1; i >= 0; i--) {
+    const key = getKey(oldChildren[i]);
+    if (key === void 0) {
+      const node = parent.childNodes[i];
+      if (node) {
+        callRef(oldChildren[i], null);
+        node.remove();
       }
-      _pendingMountQueue = prevMount;
-      _pendingCleanupQueue = prevCleanup;
     }
-    return result;
   }
-  const el = document.createElement(type);
-  if (props) {
-    for (const [k, v] of Object.entries(props)) {
-      if (k !== "children") setProp(el, k, v);
+  let insertBefore = parent.firstChild;
+  for (let i = newChildren.length - 1; i >= 0; i--) {
+    const key = newKeys[i];
+    const newChild = newChildren[i];
+    const oldEntry = key !== void 0 ? oldKeyMap.get(key) : void 0;
+    if (oldEntry && oldEntry.node) {
+      parent.insertBefore(oldEntry.node, insertBefore);
+      insertBefore = oldEntry.node;
+      patchValue(parent, oldEntry.node, oldEntry.vnode, newChild, ctx);
+    } else {
+      const node = renderValue(newChild, ctx);
+      parent.insertBefore(node, insertBefore);
+      insertBefore = node;
     }
   }
-  const childList = children.length > 0 ? children : props?.children != null ? [props.children] : [];
-  for (const child of childList) appendChild(el, child);
-  return el;
 }
-function jsxs(type, props, ...children) {
-  return jsx(type, props, ...children);
-}
-function jsxDEV(type, props, _key, _isStatic, _source, _self) {
-  return jsx(type, props, ...props?.children ? [props.children] : []);
-}
-function Fragment(props, ..._rest) {
-  const childList = props?.children != null ? Array.isArray(props.children) ? props.children : [props.children] : [];
-  const el = document.createElement("div");
-  el.style.display = "contents";
-  for (const child of childList) appendChild(el, child);
-  return el;
-}
-function domMount(root, app) {
-  const container = typeof root === "string" ? document.querySelector(root) : root;
-  if (!container) throw new Error(`mount target not found: ${root}`);
-  container.innerHTML = "";
-  container.appendChild(app);
+function callRef(input, el) {
+  if (input == null || typeof input !== "object") return;
+  const vnode = input;
+  if (typeof vnode.props?.ref === "function") {
+    vnode.props.ref(el);
+  }
+  forEach(vnode.props?.children, (child) => callRef(child, el));
 }
-function ErrorBoundary({ fallback, children, onError }, _ctx) {
-  try {
-    return children();
-  } catch (e) {
-    const err = e;
-    if (onError) onError(err);
-    return fallback(err);
+
+// src/client/router.ts
+function flattenRoutes(routes, basePath = "", chain = []) {
+  const result = [];
+  for (const route of routes) {
+    const fullPath = joinPaths(basePath, route.path);
+    const { re, keys } = compilePath(fullPath);
+    const fullChain = [...chain, route];
+    result.push({ re, keys, def: route, chain: fullChain });
+    if (route.children) {
+      result.push(...flattenRoutes(route.children, fullPath, fullChain));
+    }
   }
+  return result;
 }
-function createPortal(node, target) {
-  target.appendChild(node);
-  return document.createDocumentFragment();
+var layoutDepth = /* @__PURE__ */ new WeakMap();
+function joinPaths(a, b) {
+  if (!b || b === "/") return a || "/";
+  const left = a.endsWith("/") ? a.slice(0, -1) : a;
+  const right = b.startsWith("/") ? b : "/" + b;
+  return left + right;
 }
-function toNode(v) {
-  if (v instanceof Node) return v;
-  if (typeof v === "function") return toNode(v());
-  return document.createTextNode(String(v ?? ""));
+function compilePath(path) {
+  const keys = [];
+  const reStr = path.replace(/:(\w+)/g, (_, key) => {
+    keys.push(key);
+    return "([^/]+)";
+  }).replace(/\*/g, ".*");
+  return { re: new RegExp(`^${reStr}$`), keys };
 }
-function Show({ when, children, fallback }) {
-  const el = document.createElement("div");
-  el.style.display = "contents";
-  function render(show) {
-    while (el.lastChild) el.removeChild(el.lastChild);
-    if (show && children != null) {
-      el.appendChild(toNode(children));
-    } else if (!show && fallback != null) {
-      el.appendChild(toNode(fallback));
+function matchRoute(path, routes) {
+  let best = null;
+  for (const fr of routes) {
+    if (path.match(fr.re)) {
+      if (!best || fr.chain.length > best.chain.length) best = fr;
     }
   }
-  if (isSignal(when)) {
-    const dispose = effect(() => render(Boolean(when.value)));
-    _trackEffect(el, dispose);
-  } else {
-    render(Boolean(when));
-  }
-  return el;
+  return best;
 }
-function For({ each, children, keyBy }) {
-  const el = document.createElement("div");
-  el.style.display = "contents";
-  function getKey(item, index) {
-    if (typeof keyBy === "function") return keyBy(item);
-    if (typeof keyBy === "string") return String(item[keyBy] ?? index);
-    return String(index);
-  }
-  function render(list) {
-    if (list == null) list = [];
-    if (!keyBy) {
-      while (el.lastChild) el.removeChild(el.lastChild);
-      for (let i = 0; i < list.length; i++) {
-        el.appendChild(children(list[i], i));
+function router(opts) {
+  const flatRoutes = flattenRoutes(opts.routes);
+  const mode = opts.mode || "history";
+  function getPath() {
+    if (mode === "hash") {
+      const hash = window.location.hash.replace(/^#/, "") || "/";
+      return hash;
+    }
+    return window.location.pathname;
+  }
+  function resolve(path) {
+    const match = matchRoute(path, flatRoutes);
+    if (match) {
+      const params = {};
+      const m = path.match(match.re);
+      if (m) {
+        for (let i = 0; i < match.keys.length; i++) {
+          params[match.keys[i]] = decodeURIComponent(m[i + 1]);
+        }
       }
-      return;
-    }
-    const oldNodes = Array.from(el.children).filter((n) => n instanceof Element);
-    const oldKeyMap = /* @__PURE__ */ new Map();
-    for (const node of oldNodes) {
-      const k = node.getAttribute("data-key");
-      if (k !== null) oldKeyMap.set(k, node);
-    }
-    const newKeys = [];
-    const newItems = [];
-    for (let i = 0; i < list.length; i++) {
-      newKeys.push(getKey(list[i], i));
-      newItems.push(list[i]);
-    }
-    const removedKeys = new Set(oldKeyMap.keys());
-    for (const k of newKeys) removedKeys.delete(k);
-    for (const k of removedKeys) {
-      const node = oldKeyMap.get(k);
-      node.remove();
-      oldKeyMap.delete(k);
+      return {
+        path: match.def.path,
+        params,
+        query: Object.fromEntries(new URLSearchParams(window.location.search)),
+        chain: match.chain
+      };
     }
-    let insertBefore = el.firstChild;
-    for (let i = list.length - 1; i >= 0; i--) {
-      const key = newKeys[i];
-      const existing = oldKeyMap.get(key);
-      if (existing) {
-        el.insertBefore(existing, insertBefore);
-        insertBefore = existing;
+    return { path, params: {}, query: {}, chain: [] };
+  }
+  return (ctx) => {
+    const resolved = resolve(getPath());
+    ctx.route = resolved;
+    if (!ctx.app) ctx.app = {};
+    ctx.app.navigate = (path) => {
+      if (mode === "hash") {
+        window.location.hash = "#" + path;
+        const resolved2 = resolve(path);
+        ctx.route = resolved2;
       } else {
-        const node = children(newItems[i], i);
-        if (node instanceof Element) {
-          node.setAttribute("data-key", key);
-        }
-        el.insertBefore(node, insertBefore);
-        insertBefore = node;
+        window.history.pushState({}, "", path);
+        const resolved2 = resolve(path);
+        ctx.route = resolved2;
       }
+      ctx.ui?.render();
+    };
+    const onPop = () => {
+      const resolved2 = resolve(getPath());
+      ctx.route = resolved2;
+      ctx.ui?.render();
+    };
+    window.addEventListener("popstate", onPop);
+    if (mode === "hash") {
+      window.addEventListener("hashchange", onPop);
     }
-  }
-  if (isSignal(each)) {
-    const dispose = effect(() => render(each.value));
-    _trackEffect(el, dispose);
-  } else {
-    render(each);
-  }
-  return el;
-}
-
-// src/client/types.ts
-function createContext(key) {
-  return {
-    provide: (ctx, value) => ctx.provide(key, value),
-    inject: (ctx) => ctx.inject(key)
+    return ctx;
   };
 }
-function extendCtx(ctx, fields) {
-  return Object.assign(Object.create(ctx), fields);
+function RouteView(_props, ctx) {
+  const route = ctx.route;
+  if (!route?.chain?.length) return null;
+  const ctxAny = ctx;
+  const depth = layoutDepth.get(ctxAny) ?? 0;
+  if (depth >= route.chain.length) return null;
+  const def = route.chain[depth];
+  const Comp = def.layout ?? def.component;
+  if (!Comp) return null;
+  if (def.layout) {
+    layoutDepth.set(ctxAny, depth + 1);
+  }
+  return { type: Comp, props: {}, key: void 0 };
 }
 
 // src/client/app.ts
+var mutationMethods = ["push", "pop", "splice", "shift", "unshift", "sort", "reverse"];
+var wrappedCache = /* @__PURE__ */ new WeakMap();
+function wrapDeep(val, dirty) {
+  if (val === null || typeof val !== "object") return val;
+  if (val instanceof Node) return val;
+  if (wrappedCache.has(val)) return wrappedCache.get(val);
+  let proxy;
+  if (Array.isArray(val)) {
+    proxy = new Proxy(val, {
+      get(target, key, receiver) {
+        const v = Reflect.get(target, key, receiver);
+        if (typeof key === "string" && mutationMethods.includes(key) && typeof v === "function") {
+          return function(...args) {
+            const r = v.apply(target, args);
+            dirty();
+            return r;
+          };
+        }
+        return wrapDeep(v, dirty);
+      },
+      set(target, key, val2) {
+        target[key] = wrapDeep(val2, dirty);
+        dirty();
+        return true;
+      }
+    });
+  } else {
+    proxy = new Proxy(val, {
+      get(_target, key, receiver) {
+        const v = Reflect.get(_target, key, receiver);
+        return wrapDeep(v, dirty);
+      },
+      set(target, key, val2) {
+        target[key] = wrapDeep(val2, dirty);
+        dirty();
+        return true;
+      }
+    });
+  }
+  wrappedCache.set(val, proxy);
+  return proxy;
+}
 function createApp() {
   const middlewares = [];
-  const provides = /* @__PURE__ */ new Map();
-  let ctx = {
-    route: {
-      path: window.location.pathname,
-      params: {},
-      query: Object.fromEntries(new URLSearchParams(window.location.search)),
-      hash: window.location.hash,
-      component: null,
-      data: {},
-      loading: false
-    },
-    app: {
-      navigate(path) {
-        window.history.pushState({}, "", path);
-        ctx.route.path = path;
-        ctx.route.query = Object.fromEntries(new URLSearchParams(window.location.search));
-        ctx.route.hash = window.location.hash;
-        const Ctor = window.CustomEvent || CustomEvent;
-        window.dispatchEvent(new Ctor("wefu:navigate", { detail: { path } }));
-      }
-    },
-    provide(key, value) {
-      provides.set(key, value);
-    },
-    inject(key) {
-      return provides.get(key) ?? null;
-    },
-    ws: null
-  };
-  return {
+  let ctx = {};
+  let container = null;
+  let rootComponent = null;
+  let oldVNode = null;
+  let rendered = false;
+  const app = {
     get ctx() {
       return ctx;
     },
     use(mw) {
       middlewares.push(mw);
-      return this;
+      return app;
     },
     async mount(rootSelector, RootComponent) {
+      rootComponent = RootComponent;
       for (const mw of middlewares) {
         ctx = await mw(ctx);
       }
-      setCtx(ctx);
-      const app = jsx(RootComponent, {});
-      domMount(rootSelector, app);
-      setCtx(null);
-    },
-    hydrate(selector, Component, props) {
-      const root = document.querySelector(selector);
-      if (!root) {
-        console.warn(`hydrate target not found: ${selector}`);
-        return;
-      }
-      const mergedProps = props ?? window.__WFUI_PROPS__ ?? {};
-      setCtx(ctx);
-      const vnode = jsx(Component, mergedProps);
-      root.appendChild(vnode);
-      setCtx(null);
-    }
-  };
-}
-
-// src/client/router.ts
-var CHAIN_KEY = /* @__PURE__ */ Symbol("routeChain");
-var DEPTH_KEY = /* @__PURE__ */ Symbol("routeDepth");
-function router(opts) {
-  const mode = opts.mode ?? "hash";
-  const flatRoutes = flattenRoutes(opts.routes);
-  function matchRoute(path) {
-    for (const fr of flatRoutes) {
-      const result = path.match(fr.re);
-      if (!result) continue;
-      const isLeaf = (idx) => idx === fr.chain.length - 1;
-      const matchedChain = fr.chain.map((item, idx) => {
-        const params = {};
-        if (isLeaf(idx)) {
-          fr.keys.forEach((k, i) => {
-            params[k] = decodeURIComponent(result[i + 1]);
-          });
-        }
-        return { ...item, params };
-      });
-      return { chain: matchedChain, leafRoute: fr.leafRoute };
-    }
-    return null;
-  }
-  function resolve(ctx2, path) {
-    const raw = mode === "hash" ? path || "/" : path;
-    const [cleanPath, qs] = raw.split("?");
-    ctx2.route.query = Object.fromEntries(new URLSearchParams(qs ?? ""));
-    ctx2.route.path = cleanPath;
-    const matched = matchRoute(cleanPath);
-    if (!matched) {
-      ctx2.route.component = opts.notFound ?? null;
-      ctx2.route.data = {};
-      ctx2.route.transition = opts.transition;
-      ctx2.route[CHAIN_KEY] = [];
-      return;
-    }
-    const leaf = matched.chain[matched.chain.length - 1];
-    ctx2.route.params = { ...leaf.params };
-    ctx2.route.component = leaf.component ?? leaf.routeDef.component ?? null;
-    ctx2.route.title = matched.leafRoute.title;
-    ctx2.route.auth = matched.leafRoute.auth;
-    ctx2.route.transition = matched.leafRoute.transition ?? opts.transition;
-    if (matched.leafRoute.title) document.title = matched.leafRoute.title;
-    ctx2.route[CHAIN_KEY] = matched.chain;
-    ctx2.route[DEPTH_KEY] = 0;
-  }
-  return (ctx) => {
-    function emit(path) {
-      const Ctor = window.CustomEvent || CustomEvent;
-      window.dispatchEvent(new Ctor("wefu:route", { detail: { path } }));
-    }
-    function navigateAndLoad(path) {
-      resolve(ctx, path);
-      const leafChain = ctx.route[CHAIN_KEY];
-      const leafLoader = leafChain?.[leafChain.length - 1]?.routeDef?.loader;
-      if (leafLoader) {
-        ctx.route.loading = true;
-        emit(ctx.route.path);
-        leafLoader(ctx).then((data) => {
-          ctx.route.data = data;
-          ctx.route.loading = false;
-          emit(ctx.route.path);
-        }).catch(() => {
-          ctx.route.data = {};
-          ctx.route.loading = false;
-          emit(ctx.route.path);
+      const el = typeof rootSelector === "string" ? document.querySelector(rootSelector) : rootSelector;
+      if (!el) throw new Error(`mount target not found: ${rootSelector}`);
+      container = el;
+      container.innerHTML = "";
+      let _dirty = false;
+      function scheduleRender() {
+        if (_dirty) return;
+        _dirty = true;
+        queueMicrotask(() => {
+          if (!_dirty) return;
+          _dirty = false;
+          ctx.ui.render();
         });
-      } else {
-        ctx.route.loading = false;
-        emit(ctx.route.path);
       }
-    }
-    if (mode === "hash") {
-      ctx.app.navigate = (path) => {
-        window.location.hash = "#" + path;
-      };
-      window.addEventListener("hashchange", () => {
-        navigateAndLoad(window.location.hash.slice(1) || "/");
-      });
-    } else {
-      const scrollPositions = /* @__PURE__ */ new Map();
-      ctx.app.navigate = (path) => {
-        if (opts.scrollRestoration !== false) {
-          scrollPositions.set(window.location.pathname, window.scrollY);
-        }
-        window.history.pushState({}, "", path);
-        navigateAndLoad(path);
-      };
-      window.addEventListener("popstate", () => {
-        if (opts.scrollRestoration !== false) {
-          const savedY = scrollPositions.get(window.location.pathname);
-          if (savedY !== void 0) {
-            requestAnimationFrame(() => window.scrollTo(0, savedY));
+      const $target = {};
+      ctx.ui = {
+        render: () => {
+          if (!container || !rootComponent || !oldVNode) return;
+          _dirty = false;
+          layoutDepth.delete(ctx);
+          const newVNode = wrapComponent(rootComponent, ctx);
+          const oldNode = container.firstChild;
+          if (oldNode) {
+            patchValue(container, oldNode, oldVNode, newVNode, ctx);
           }
-        }
-        navigateAndLoad(window.location.pathname + window.location.search);
-      });
-    }
-    const initialPath = mode === "hash" ? window.location.hash.slice(1) || "/" : window.location.pathname + window.location.search;
-    navigateAndLoad(initialPath);
-    return ctx;
-  };
-}
-function flattenRoutes(routes, parentPath = "") {
-  const result = [];
-  for (const route of routes) {
-    const fullPath = parentPath + route.path;
-    const parts = fullPath.split("/").filter(Boolean);
-    const keys = [];
-    const reStr = "^/" + parts.map((p) => {
-      if (p.startsWith(":")) {
-        keys.push(p.slice(1));
-        return "([^/]+)";
-      }
-      return p;
-    }).join("/") + "$";
-    if (route.children && route.children.length > 0) {
-      for (const child of route.children) {
-        const childPath = fullPath + child.path;
-        const childParts = childPath.split("/").filter(Boolean);
-        const childKeys = [];
-        const childReStr = "^/" + childParts.map((p) => {
-          if (p.startsWith(":")) {
-            childKeys.push(p.slice(1));
-            return "([^/]+)";
+          oldVNode = newVNode;
+        },
+        /** 极少需要：仅当绕过 Proxy 直接操作底层对象时使用 */
+        dirty: () => {
+          scheduleRender();
+        },
+        $: new Proxy($target, {
+          set(_target, key, val) {
+            _target[key] = wrapDeep(val, scheduleRender);
+            scheduleRender();
+            return true;
           }
-          return p;
-        }).join("/") + "$";
-        const chain = [
-          { layout: route.layout, params: {}, routeDef: route, depth: 0 },
-          { component: child.component, params: {}, routeDef: child, depth: 1 }
-        ];
-        result.push({
-          re: new RegExp(childReStr),
-          keys: childKeys,
-          chain,
-          leafRoute: child
-        });
-      }
-    } else {
-      const chain = [
-        { component: route.component, params: {}, routeDef: route, depth: 0 }
-      ];
-      result.push({
-        re: new RegExp(reStr),
-        keys,
-        chain,
-        leafRoute: route
-      });
+        }),
+        ready: false
+      };
+      oldVNode = wrapComponent(RootComponent, ctx);
+      const node = render(oldVNode, ctx);
+      if (node instanceof Node) container.appendChild(node);
+      _dirty = false;
+      rendered = true;
+    },
+    destroy() {
+      if (container) container.innerHTML = "";
+      container = null;
+      ctx = {};
     }
-  }
-  return result;
+  };
+  return app;
 }
-function RouteView(_props, ctx) {
-  const el = document.createElement("div");
-  let myDepth = null;
-  let cachedComp = null;
-  function render() {
-    const chain = ctx.route[CHAIN_KEY];
-    if (myDepth === null) {
-      const d = ctx.route[DEPTH_KEY] ?? 0;
-      myDepth = d;
-      ctx.route[DEPTH_KEY] = myDepth + 1;
-    }
-    const depth = myDepth;
-    if (!chain || depth >= chain.length) {
-      if (el.children.length > 0) el.textContent = "";
-      cachedComp = null;
-      return;
-    }
-    const item = chain[depth];
-    const Comp = item.layout ?? item.component;
-    if (!Comp) return;
-    if (cachedComp === Comp) return;
-    cachedComp = Comp;
-    el.textContent = "";
-    setCtx(ctx);
-    const page = jsx(Comp, {});
-    el.appendChild(page);
-    setCtx(null);
-  }
-  render();
-  window.addEventListener("wefu:route", render);
-  onCleanup(() => window.removeEventListener("wefu:route", render));
-  return el;
+function wrapComponent(Comp, _ctx) {
+  return { type: Comp, props: {}, key: void 0 };
 }
 
-// src/client/lazy.ts
-function lazy(loader, options) {
-  let loaded = null;
-  let error = null;
-  let status = "pending";
-  let loadingPromise = null;
-  function startLoad() {
-    if (status !== "pending") return;
-    status = "loading";
-    loadingPromise = loader().then((mod) => {
-      loaded = "default" in mod ? mod.default : mod;
-      status = "loaded";
-    }).catch((e) => {
-      error = e;
-      status = "error";
-    });
-  }
-  return (props, ctx) => {
-    if (loaded) {
-      return loaded(props, ctx);
-    }
-    if (error) {
-      const ErrorComp = options?.errorFallback;
-      if (ErrorComp) return ErrorComp(props, ctx);
-      const el2 = document.createElement("div");
-      el2.textContent = `\u7EC4\u4EF6\u52A0\u8F7D\u5931\u8D25: ${error.message}`;
-      el2.style.cssText = "padding: 1rem; color: #ef4444;";
-      return el2;
-    }
-    if (status === "pending") {
-      startLoad();
-    }
-    if (status === "loading" && loadingPromise) {
-      loadingPromise.then(() => {
-        setTimeout(() => {
-          window.dispatchEvent(new CustomEvent("wefu:lazy-loaded"));
-        }, 0);
-      });
-    }
-    const Fallback = options?.fallback;
-    if (Fallback) return Fallback(props, ctx);
-    const el = document.createElement("div");
-    el.textContent = "\u52A0\u8F7D\u4E2D...";
-    el.style.cssText = "padding: 1rem; color: #6b7280;";
-    return el;
-  };
+// src/client/types.ts
+function extendCtx(ctx, fields) {
+  return Object.assign(Object.create(ctx), fields);
 }
 
 // src/client/middleware/ws.ts
-function ws(opts = {}) {
-  const wsUrl = opts.url ?? "/ws";
-  const reconnectInterval = opts.reconnectInterval ?? 3e3;
-  const maxReconnect = opts.maxReconnect ?? 10;
+function ws(options = {}) {
+  const wsUrl = options.url ?? "/ws";
+  const reconnectInterval = options.reconnectInterval ?? 3e3;
+  const maxReconnect = options.maxReconnect ?? 10;
+  const pingIntervalMs = options.pingInterval ?? 3e4;
+  const pingTimeoutMs = options.pingTimeout ?? 1e4;
   return (ctx) => {
-    const isConnected = signal(false);
     const messageHandlers = /* @__PURE__ */ new Set();
     let socket = null;
-    let reconnectCount = 0;
+    let reconnectAttempts = 0;
     let reconnectTimer = null;
-    function connect() {
-      if (socket?.readyState === WebSocket.OPEN || socket?.readyState === WebSocket.CONNECTING) return;
-      const url = wsUrl;
+    let pingTimer = null;
+    let pingTimeoutTimer = null;
+    let destroyed = false;
+    const wsClient = {
+      isConnected: false,
+      onMessage: (fn) => {
+        messageHandlers.add(fn);
+        return () => {
+          messageHandlers.delete(fn);
+        };
+      },
+      send: (msg) => {
+        if (socket?.readyState === WebSocket.OPEN) {
+          socket.send(JSON.stringify(msg));
+        }
+      },
+      _connect: connect,
+      /** 断开连接并清理所有定时器 */
+      close: () => {
+        destroyed = true;
+        clearTimers();
+        socket?.close();
+        socket = null;
+        wsClient.isConnected = false;
+      }
+    };
+    async function connect() {
+      if (destroyed) return;
       try {
-        socket = new WebSocket(url);
+        socket = new WebSocket(wsUrl);
+        socket.onopen = () => {
+          wsClient.isConnected = true;
+          reconnectAttempts = 0;
+          startPing();
+        };
+        socket.onmessage = (e) => {
+          try {
+            const data = JSON.parse(e.data);
+            for (const handler of messageHandlers) handler(data);
+          } catch {
+          }
+          resetPingTimeout();
+        };
+        socket.onclose = () => {
+          wsClient.isConnected = false;
+          clearTimers();
+          if (!destroyed && reconnectAttempts < maxReconnect) {
+            reconnectAttempts++;
+            reconnectTimer = setTimeout(connect, reconnectInterval * Math.min(reconnectAttempts, 5));
+          }
+        };
+        socket.onerror = () => {
+          socket?.close();
+        };
       } catch {
-        scheduleReconnect();
-        return;
+        if (!destroyed) {
+          reconnectTimer = setTimeout(connect, reconnectInterval);
+        }
       }
-      socket.onopen = () => {
-        isConnected.value = true;
-        reconnectCount = 0;
-      };
-      socket.onmessage = (event) => {
-        try {
-          const data = JSON.parse(event.data);
-          for (const h of messageHandlers) h(data);
-        } catch {
-          for (const h of messageHandlers) h(event.data);
+    }
+    function startPing() {
+      if (pingIntervalMs <= 0) return;
+      pingTimer = setInterval(() => {
+        if (socket?.readyState === WebSocket.OPEN) {
+          socket.send(JSON.stringify({ type: "ping" }));
         }
-      };
-      socket.onclose = () => {
-        isConnected.value = false;
-        socket = null;
-        scheduleReconnect();
-      };
-      socket.onerror = () => {
-        socket?.close();
-      };
+        pingTimeoutTimer = setTimeout(() => {
+          socket?.close();
+        }, pingTimeoutMs);
+      }, pingIntervalMs);
     }
-    function scheduleReconnect() {
-      if (reconnectCount >= maxReconnect) return;
-      reconnectCount++;
-      reconnectTimer = setTimeout(connect, reconnectInterval * reconnectCount);
+    function resetPingTimeout() {
+      clearTimeout(pingTimeoutTimer);
     }
-    function send(data) {
-      if (socket?.readyState === WebSocket.OPEN) {
-        socket.send(typeof data === "string" ? data : JSON.stringify(data));
-      } else {
-        console.warn("ws.send: WebSocket not open, readyState:", socket?.readyState);
-      }
+    function clearTimers() {
+      clearInterval(pingTimer);
+      clearTimeout(pingTimeoutTimer);
+      clearTimeout(reconnectTimer);
     }
     connect();
-    return extendCtx(ctx, {
-      ws: {
-        send,
-        onMessage: (handler) => {
-          messageHandlers.add(handler);
-          return () => messageHandlers.delete(handler);
-        },
-        get isConnected() {
-          return isConnected;
-        }
-      }
-    });
+    return extendCtx(ctx, { ws: wsClient });
   };
 }
 
@@ -815,13 +680,27 @@ function api(options) {
   };
   const onRequest = options?.onRequest;
   const onResponse = options?.onResponse;
+  const timeoutMs = options?.timeout ?? 0;
   async function request(method, url, body, reqOpts) {
     const fullURL = opts.baseURL + url;
     const init = {
       method,
-      headers: { ...opts.headers, ...reqOpts?.headers },
-      signal: reqOpts?.signal
+      headers: { ...opts.headers, ...reqOpts?.headers }
     };
+    const hasTimeout = timeoutMs > 0;
+    const hasUserSignal = !!reqOpts?.signal;
+    let abortController = null;
+    let timer = null;
+    if (hasTimeout || hasUserSignal) {
+      abortController = new AbortController();
+      init.signal = abortController.signal;
+      if (hasTimeout) {
+        timer = setTimeout(() => abortController.abort(new Error("Request timed out")), timeoutMs);
+      }
+      if (hasUserSignal) {
+        reqOpts.signal.addEventListener("abort", () => abortController.abort());
+      }
+    }
     if (body !== void 0 && method !== "GET" && method !== "HEAD") {
       init.body = JSON.stringify(body);
     }
@@ -829,19 +708,27 @@ function api(options) {
     if (onRequest) {
       finalReq = onRequest(finalReq);
     }
-    const res = await fetch(finalReq.url, finalReq.init);
-    if (onResponse) {
-      return onResponse(res);
-    }
-    if (!res.ok) {
-      const text = await res.text().catch(() => "");
-      throw new ApiError(res.status, text || res.statusText);
-    }
-    const contentLength = res.headers.get("content-length");
-    if (res.status === 204 || contentLength === "0") {
-      return void 0;
+    try {
+      const res = await fetch(finalReq.url, finalReq.init);
+      if (onResponse) {
+        return onResponse(res);
+      }
+      if (!res.ok) {
+        const text = await res.text().catch(() => "");
+        throw new ApiError(res.status, text || res.statusText);
+      }
+      const contentLength = res.headers.get("content-length");
+      if (res.status === 204 || contentLength === "0") {
+        return void 0;
+      }
+      const ct = (res.headers.get("content-type") || "").toLowerCase();
+      if (ct.includes("application/json") || ct.includes("json")) {
+        return res.json();
+      }
+      return res.text();
+    } finally {
+      if (timer) clearTimeout(timer);
     }
-    return res.json();
   }
   return (ctx) => {
     const client = {
@@ -851,8 +738,7 @@ function api(options) {
       patch: (url, body, reqOpts) => request("PATCH", url, body, reqOpts),
       delete: (url, reqOpts) => request("DELETE", url, void 0, reqOpts)
     };
-    ctx.api = client;
-    return ctx;
+    return extendCtx(ctx, { api: client });
   };
 }
 var ApiError = class extends Error {
@@ -867,207 +753,126 @@ var ApiError = class extends Error {
 };
 
 // src/client/middleware/auth.ts
+function decodeJWT(token) {
+  try {
+    const parts = token.split(".");
+    if (parts.length !== 3) return null;
+    const payload = parts[1].replace(/-/g, "+").replace(/_/g, "/");
+    return JSON.parse(atob(payload));
+  } catch {
+    return null;
+  }
+}
+function isTokenExpired(token) {
+  const payload = decodeJWT(token);
+  if (!payload?.exp) return true;
+  return payload.exp * 1e3 - 3e4 < Date.now();
+}
 function auth(options) {
   const storage = options?.storage ?? localStorage;
   const tokenKey = options?.tokenKey ?? "weifuwu_token";
   const userKey = options?.userKey ?? "weifuwu_user";
+  const refreshTokenKey = options?.refreshTokenKey ?? "weifuwu_refresh";
+  const refreshEndpoint = options?.refreshEndpoint ?? "/api/auth/refresh";
   return (ctx) => {
     const savedToken = storage.getItem(tokenKey);
     const savedUserStr = storage.getItem(userKey);
-    const token = signal(savedToken);
-    const user = signal(
-      savedUserStr ? JSON.parse(savedUserStr) : null
-    );
-    const isLoggedIn = computed(() => token.value !== null);
-    const authorizationHeader = computed(() => token.value ? `Bearer ${token.value}` : null);
     const authClient = {
-      token,
-      user,
-      isLoggedIn,
-      authorizationHeader,
-      login(newToken, newUser) {
-        token.value = newToken;
-        user.value = newUser;
+      token: savedToken,
+      user: savedUserStr ? JSON.parse(savedUserStr) : null,
+      get isLoggedIn() {
+        return this.token !== null;
+      },
+      login(newToken, newUser, refreshToken) {
+        authClient.token = newToken;
+        authClient.user = newUser;
         storage.setItem(tokenKey, newToken);
         storage.setItem(userKey, JSON.stringify(newUser));
+        if (refreshToken) storage.setItem(refreshTokenKey, refreshToken);
       },
       logout() {
-        token.value = null;
-        user.value = null;
+        authClient.token = null;
+        authClient.user = null;
         storage.removeItem(tokenKey);
         storage.removeItem(userKey);
+        storage.removeItem(refreshTokenKey);
       },
       setUser(newUser) {
-        user.value = newUser;
+        authClient.user = newUser;
         storage.setItem(userKey, JSON.stringify(newUser));
+      },
+      async refresh() {
+        const rt = storage.getItem(refreshTokenKey);
+        if (!rt) return false;
+        try {
+          const res = await fetch(refreshEndpoint, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ refreshToken: rt })
+          });
+          if (!res.ok) {
+            authClient.logout();
+            return false;
+          }
+          const data = await res.json();
+          authClient.token = data.token;
+          storage.setItem(tokenKey, data.token);
+          if (data.refreshToken) storage.setItem(refreshTokenKey, data.refreshToken);
+          return true;
+        } catch {
+          return false;
+        }
       }
     };
-    ctx.auth = authClient;
-    return ctx;
-  };
-}
-
-// src/client/resource.ts
-function createResource(fetcher, options) {
-  const data = signal(options?.initialValue);
-  const loading = signal(true);
-  const error = signal(void 0);
-  let fetchId = 0;
-  async function load() {
-    const id = ++fetchId;
-    loading.value = true;
-    error.value = void 0;
-    try {
-      const result = await fetcher();
-      if (id === fetchId) {
-        data.value = result;
-        loading.value = false;
-      }
-    } catch (e) {
-      if (id === fetchId) {
-        error.value = e instanceof Error ? e : new Error(String(e));
-        loading.value = false;
-      }
-    }
-  }
-  load();
-  const state = {
-    data,
-    loading,
-    error,
-    refetch: () => {
-      load();
+    if (savedToken && isTokenExpired(savedToken)) {
+      authClient.refresh().catch(() => {
+      });
     }
+    return extendCtx(ctx, { auth: authClient });
   };
-  return [data, state];
 }
 
-// src/client/form.ts
-function useForm(options) {
-  const values = signal({ ...options.initial });
-  const errors = signal({});
-  const submitting = signal(false);
-  const touched = signal({});
-  function getValidators(name) {
-    const rules = options.validate?.[name];
-    if (!rules) return [];
-    return Array.isArray(rules) ? rules : [rules];
-  }
-  function validateField(name, value) {
-    const validators = getValidators(name);
-    for (const v of validators) {
-      const err = v(value);
-      if (err !== null) return err;
-    }
-    return null;
-  }
-  function validateAllFields() {
-    const newErrors = {};
-    let hasError = false;
-    for (const key of Object.keys(values.value)) {
-      const err = validateField(key, values.value[key]);
-      newErrors[key] = err;
-      if (err !== null) hasError = true;
-    }
-    errors.value = newErrors;
-    return !hasError;
-  }
-  function handleSubmit(e) {
-    e.preventDefault();
-    if (submitting.value) return;
-    const allTouched = {};
-    for (const key of Object.keys(values.value)) {
-      allTouched[key] = true;
-    }
-    touched.value = allTouched;
-    if (!validateAllFields()) return;
-    if (options.onSubmit) {
-      submitting.value = true;
-      const result = options.onSubmit({ ...values.value });
-      if (result instanceof Promise) {
-        result.finally(() => {
-          submitting.value = false;
-        });
-      } else {
-        submitting.value = false;
-      }
+// src/client/error-boundary.ts
+function ErrorBoundary(props, ctx) {
+  const $ = ctx.ui.$;
+  if (!("error" in $)) $.error = null;
+  if ($.error) {
+    const fb = props.fallback;
+    if (typeof fb === "function") {
+      return fb({ error: $.error });
+    }
+    return fb ?? null;
+  }
+  ;
+  ctx.ui._errorHandler = (err) => {
+    $.error = err;
+    ctx.ui.dirty();
+  };
+  try {
+    const result = props.children;
+    return result ?? null;
+  } catch (e) {
+    $.error = e;
+    const fb = props.fallback;
+    if (typeof fb === "function") {
+      return fb({ error: e });
     }
+    return fb ?? null;
   }
-  function field(name) {
-    const fieldError = {
-      get value() {
-        return errors.value[name];
-      }
-    };
-    return {
-      get value() {
-        return String(values.value[name] ?? "");
-      },
-      onInput(e) {
-        const target = e.target;
-        const newVal = target.type === "checkbox" ? target.checked : target.value;
-        const newValues = { ...values.value, [name]: newVal };
-        values.value = newValues;
-        if (touched.value[name]) {
-          const err = validateField(name, newVal);
-          errors.value = { ...errors.value, [name]: err };
-        }
-      },
-      get error() {
-        return fieldError;
-      }
-    };
-  }
-  function setValue(name, value) {
-    values.value = { ...values.value, [name]: value };
-  }
-  function reset() {
-    values.value = { ...options.initial };
-    errors.value = {};
-    touched.value = {};
-    submitting.value = false;
-  }
-  return {
-    values,
-    errors,
-    submitting,
-    touched,
-    handleSubmit,
-    field,
-    setValue,
-    reset,
-    validateAll: validateAllFields
-  };
 }
 export {
   ApiError,
   ErrorBoundary,
-  For,
   Fragment,
   RouteView,
-  Show,
   api,
   auth,
-  batch,
-  computed,
   createApp,
-  createContext,
-  createPortal,
-  createResource,
-  domMount,
-  effect,
   extendCtx,
-  isSignal,
+  h,
   jsx,
   jsxDEV,
   jsxs,
-  lazy,
-  onCleanup,
-  onMount,
   router,
-  signal,
-  untrack,
-  useForm,
-  wrap,
   ws
 };