wevu 0.0.0 → 0.0.2-alpha.0

package/dist/index.mjs

@@ -1,699 +1,1290 @@
-const resolvedPromise = Promise.resolve();
-const jobQueue = /* @__PURE__ */ new Set();
-let isFlushing = false;
-function flushJobs() {
-  isFlushing = true;
-  try {
-    jobQueue.forEach((job) => job());
-  } finally {
-    jobQueue.clear();
-    isFlushing = false;
-  }
-}
-function queueJob(job) {
-  jobQueue.add(job);
-  if (!isFlushing) {
-    resolvedPromise.then(flushJobs);
-  }
-}
-function nextTick(fn) {
-  return fn ? resolvedPromise.then(fn) : resolvedPromise;
+import { _ as computed, a as isRef, b as nextTick, c as isObject, d as isShallowReactive, f as markRaw, g as touchReactive, h as toRaw, i as customRef, l as isRaw, m as shallowReactive, n as defineStore, o as ref, p as reactive, r as createStore, s as unref, t as storeToRefs, u as isReactive, v as effect, x as queueJob, y as stop } from "./store-BcU7YVhB.mjs";
+
+//#region src/reactivity/readonly.ts
+function readonly(target) {
+	if (isRef(target)) {
+		const source = target;
+		return {
+			get value() {
+				return source.value;
+			},
+			set value(_v) {
+				throw new Error("Cannot assign to a readonly ref");
+			}
+		};
+	}
+	if (!isObject(target)) return target;
+	return new Proxy(target, {
+		set() {
+			throw new Error("Cannot set property on readonly object");
+		},
+		deleteProperty() {
+			throw new Error("Cannot delete property on readonly object");
+		},
+		defineProperty() {
+			throw new Error("Cannot define property on readonly object");
+		},
+		get(target$1, key, receiver) {
+			return Reflect.get(target$1, key, receiver);
+		}
+	});
+}
+
+//#endregion
+//#region src/reactivity/shallowRef.ts
+function shallowRef(value, defaultValue) {
+	return customRef((track, trigger) => ({
+		get() {
+			track();
+			return value;
+		},
+		set(newValue) {
+			if (Object.is(value, newValue)) return;
+			value = newValue;
+			trigger();
+		}
+	}), defaultValue);
+}
+/**
+* 判断传入值是否为浅层 ref。
+*
+* @param r 待判断的值
+* @returns 若为浅层 ref 则返回 true
+*/
+function isShallowRef(r) {
+	return r && typeof r === "object" && "value" in r && typeof r.value !== "function";
+}
+/**
+* 主动触发一次浅层 ref 的更新（无需深度比较）。
+*
+* @param ref 需要触发的 ref
+*/
+function triggerRef(ref$1) {
+	if (ref$1 && typeof ref$1 === "object" && "value" in ref$1) ref$1.value = ref$1.value;
 }
 
-const targetMap = /* @__PURE__ */ new WeakMap();
-let activeEffect = null;
-const effectStack = [];
-function cleanupEffect(effect2) {
-  const { deps } = effect2;
-  for (let i = 0; i < deps.length; i++) {
-    deps[i].delete(effect2);
-  }
-  deps.length = 0;
-}
-function createReactiveEffect(fn, options = {}) {
-  const effect2 = function reactiveEffect() {
-    if (!effect2.active) {
-      return fn();
-    }
-    if (effectStack.includes(effect2)) {
-      return fn();
-    }
-    cleanupEffect(effect2);
-    try {
-      effectStack.push(effect2);
-      activeEffect = effect2;
-      return fn();
-    } finally {
-      effectStack.pop();
-      activeEffect = effectStack[effectStack.length - 1] ?? null;
-    }
-  };
-  effect2.deps = [];
-  effect2.scheduler = options.scheduler;
-  effect2.onStop = options.onStop;
-  effect2.active = true;
-  effect2._fn = fn;
-  return effect2;
-}
-function effect(fn, options = {}) {
-  const _effect = createReactiveEffect(fn, options);
-  if (!options.lazy) {
-    _effect();
-  }
-  return _effect;
-}
-function stop(runner) {
-  if (!runner.active) {
-    return;
-  }
-  runner.active = false;
-  cleanupEffect(runner);
-  runner.onStop?.();
-}
-function track(target, key) {
-  if (!activeEffect) {
-    return;
-  }
-  let depsMap = targetMap.get(target);
-  if (!depsMap) {
-    depsMap = /* @__PURE__ */ new Map();
-    targetMap.set(target, depsMap);
-  }
-  let dep = depsMap.get(key);
-  if (!dep) {
-    dep = /* @__PURE__ */ new Set();
-    depsMap.set(key, dep);
-  }
-  if (!dep.has(activeEffect)) {
-    dep.add(activeEffect);
-    activeEffect.deps.push(dep);
-  }
-}
-function trigger(target, key) {
-  const depsMap = targetMap.get(target);
-  if (!depsMap) {
-    return;
-  }
-  const effects = depsMap.get(key);
-  if (!effects) {
-    return;
-  }
-  const effectsToRun = /* @__PURE__ */ new Set();
-  effects.forEach((effect2) => {
-    if (effect2 !== activeEffect) {
-      effectsToRun.add(effect2);
-    }
-  });
-  effectsToRun.forEach((effect2) => {
-    if (effect2.scheduler) {
-      effect2.scheduler();
-    } else {
-      effect2();
-    }
-  });
-}
-const reactiveMap = /* @__PURE__ */ new WeakMap();
-const rawMap = /* @__PURE__ */ new WeakMap();
-function isObject(value) {
-  return typeof value === "object" && value !== null;
-}
-const mutableHandlers = {
-  get(target, key, receiver) {
-    if (key === "__r_isReactive" /* IS_REACTIVE */) {
-      return true;
-    }
-    if (key === "__r_raw" /* RAW */) {
-      return target;
-    }
-    const res = Reflect.get(target, key, receiver);
-    track(target, key);
-    if (isObject(res)) {
-      return reactive(res);
-    }
-    return res;
-  },
-  set(target, key, value, receiver) {
-    const oldValue = Reflect.get(target, key, receiver);
-    const result = Reflect.set(target, key, value, receiver);
-    if (!Object.is(oldValue, value)) {
-      trigger(target, key);
-    }
-    return result;
-  },
-  deleteProperty(target, key) {
-    const hadKey = Object.prototype.hasOwnProperty.call(target, key);
-    const result = Reflect.deleteProperty(target, key);
-    if (hadKey && result) {
-      trigger(target, key);
-    }
-    return result;
-  },
-  ownKeys(target) {
-    track(target, Symbol.iterator);
-    return Reflect.ownKeys(target);
-  }
-};
-function reactive(target) {
-  if (!isObject(target)) {
-    return target;
-  }
-  const existingProxy = reactiveMap.get(target);
-  if (existingProxy) {
-    return existingProxy;
-  }
-  if (target["__r_isReactive" /* IS_REACTIVE */]) {
-    return target;
-  }
-  const proxy = new Proxy(target, mutableHandlers);
-  reactiveMap.set(target, proxy);
-  rawMap.set(proxy, target);
-  return proxy;
-}
-function isReactive(value) {
-  return Boolean(value && value["__r_isReactive" /* IS_REACTIVE */]);
-}
-function toRaw(observed) {
-  return observed?.["__r_raw" /* RAW */] ?? observed;
-}
-function convertToReactive(value) {
-  return isObject(value) ? reactive(value) : value;
-}
-function isRef(value) {
-  return Boolean(value && typeof value === "object" && "value" in value);
-}
-function trackEffects(dep) {
-  if (!activeEffect) {
-    return;
-  }
-  if (!dep.has(activeEffect)) {
-    dep.add(activeEffect);
-    activeEffect.deps.push(dep);
-  }
-}
-function triggerEffects(dep) {
-  dep.forEach((effect2) => {
-    if (effect2.scheduler) {
-      effect2.scheduler();
-    } else {
-      effect2();
-    }
-  });
-}
-function trackRefValue(refImpl) {
-  if (activeEffect) {
-    refImpl.dep = refImpl.dep || /* @__PURE__ */ new Set();
-    trackEffects(refImpl.dep);
-  }
-}
-class RefImpl {
-  _value;
-  _rawValue;
-  dep;
-  constructor(value) {
-    this._rawValue = value;
-    this._value = convertToReactive(value);
-  }
-  get value() {
-    trackRefValue(this);
-    return this._value;
-  }
-  set value(newValue) {
-    if (!Object.is(newValue, this._rawValue)) {
-      this._rawValue = newValue;
-      this._value = convertToReactive(newValue);
-      this.dep && triggerEffects(this.dep);
-    }
-  }
-}
-function ref(value) {
-  if (isRef(value)) {
-    return value;
-  }
-  return new RefImpl(value);
-}
-function unref(value) {
-  return isRef(value) ? value.value : value;
-}
-function computed(getterOrOptions) {
-  let getter;
-  let setter;
-  const onlyGetter = typeof getterOrOptions === "function";
-  if (onlyGetter) {
-    getter = getterOrOptions;
-    setter = () => {
-      throw new Error("Computed value is readonly");
-    };
-  } else {
-    getter = getterOrOptions.get;
-    setter = getterOrOptions.set;
-  }
-  let value;
-  let dirty = true;
-  let runner;
-  const obj = {
-    get value() {
-      if (dirty) {
-        value = runner();
-        dirty = false;
-      }
-      track(obj, "value");
-      return value;
-    },
-    set value(newValue) {
-      setter(newValue);
-    }
-  };
-  runner = effect(getter, {
-    lazy: true,
-    scheduler: () => {
-      if (!dirty) {
-        dirty = true;
-        trigger(obj, "value");
-      }
-    }
-  });
-  return onlyGetter ? obj : obj;
+//#endregion
+//#region src/reactivity/toRefs.ts
+/**
+* 将一个响应式对象转换成“同结构的普通对象”，其中每个字段都是指向原对象对应属性的 ref。
+*
+* @param object 待转换的响应式对象
+* @returns 包含若干 ref 的普通对象
+*
+* @example
+* ```ts
+* const state = reactive({ foo: 1, bar: 2 })
+* const stateAsRefs = toRefs(state)
+*
+* stateAsRefs.foo.value++ // 2
+* state.foo // 2
+* ```
+*/
+function toRefs(object) {
+	if (!isReactive(object)) console.warn(`toRefs() expects a reactive object but received a plain one.`);
+	const result = Array.isArray(object) ? Array.from({ length: object.length }) : {};
+	for (const key in object) result[key] = toRef(object, key);
+	return result;
+}
+function toRef(object, key, defaultValue) {
+	const value = object[key];
+	if (isRef(value)) return value;
+	return customRef((track, trigger) => ({
+		get() {
+			track();
+			return object[key];
+		},
+		set(newValue) {
+			object[key] = newValue;
+			trigger();
+		}
+	}), defaultValue);
 }
+
+//#endregion
+//#region src/reactivity/traverse.ts
 function traverse(value, seen = /* @__PURE__ */ new Set()) {
-  if (!isObject(value) || seen.has(value)) {
-    return value;
-  }
-  seen.add(value);
-  for (const key in value) {
-    traverse(value[key], seen);
-  }
-  return value;
+	if (!isObject(value) || seen.has(value)) return value;
+	seen.add(value);
+	for (const key in value) traverse(value[key], seen);
+	return value;
+}
+
+//#endregion
+//#region src/reactivity/watch.ts
+let __deepWatchStrategy = "version";
+function setDeepWatchStrategy(strategy) {
+	__deepWatchStrategy = strategy;
+}
+function getDeepWatchStrategy() {
+	return __deepWatchStrategy;
 }
 function watch(source, cb, options = {}) {
-  let getter;
-  if (typeof source === "function") {
-    getter = source;
-  } else if (isRef(source)) {
-    getter = () => source.value;
-  } else if (isReactive(source)) {
-    getter = () => source;
-  } else {
-    throw new Error("Invalid watch source");
-  }
-  if (options.deep) {
-    const baseGetter = getter;
-    getter = () => traverse(baseGetter());
-  }
-  let cleanup;
-  const onCleanup = (fn) => {
-    cleanup = fn;
-  };
-  let oldValue;
-  let runner;
-  const job = () => {
-    if (!runner.active) {
-      return;
-    }
-    const newValue = runner();
-    cleanup?.();
-    cb(newValue, oldValue, onCleanup);
-    oldValue = newValue;
-  };
-  runner = effect(() => getter(), {
-    scheduler: () => queueJob(job),
-    lazy: true
-  });
-  if (options.immediate) {
-    job();
-  } else {
-    oldValue = runner();
-  }
-  return () => {
-    cleanup?.();
-    stop(runner);
-  };
+	let getter;
+	if (typeof source === "function") getter = source;
+	else if (isRef(source)) getter = () => source.value;
+	else if (isReactive(source)) getter = () => source;
+	else throw new Error("Invalid watch source");
+	if (options.deep) {
+		const baseGetter = getter;
+		getter = () => {
+			const val = baseGetter();
+			if (__deepWatchStrategy === "version" && isReactive(val)) {
+				touchReactive(val);
+				return val;
+			}
+			return traverse(val);
+		};
+	}
+	let cleanup;
+	const onCleanup = (fn) => {
+		cleanup = fn;
+	};
+	let oldValue;
+	let runner;
+	const job = () => {
+		if (!runner.active) return;
+		const newValue = runner();
+		cleanup?.();
+		cb(newValue, oldValue, onCleanup);
+		oldValue = newValue;
+	};
+	runner = effect(() => getter(), {
+		scheduler: () => queueJob(job),
+		lazy: true
+	});
+	if (options.immediate) job();
+	else oldValue = runner();
+	return () => {
+		cleanup?.();
+		stop(runner);
+	};
+}
+/**
+* watchEffect 注册一个响应式副作用，可选清理函数。
+* 副作用会立即执行，并在依赖变化时重新运行。
+*/
+function watchEffect(effectFn) {
+	let cleanup;
+	const onCleanup = (fn) => {
+		cleanup = fn;
+	};
+	const runner = effect(() => {
+		cleanup?.();
+		cleanup = void 0;
+		effectFn(onCleanup);
+	}, { scheduler: () => queueJob(() => {
+		if (runner.active) runner();
+	}) });
+	runner();
+	return () => {
+		cleanup?.();
+		stop(runner);
+	};
 }
 
+//#endregion
+//#region src/utils.ts
 function capitalize(str) {
-  if (!str) {
-    return "";
-  }
-  return str.charAt(0).toUpperCase() + str.slice(1);
+	if (!str) return "";
+	return str.charAt(0).toUpperCase() + str.slice(1);
 }
 function toPathSegments(path) {
-  if (!path) {
-    return [];
-  }
-  return path.split(".").map((segment) => segment.trim()).filter(Boolean);
+	if (!path) return [];
+	return path.split(".").map((segment) => segment.trim()).filter(Boolean);
+}
+
+//#endregion
+//#region src/runtime/bindModel.ts
+function setComputedValue$1(setters, key, value) {
+	const setter = setters[key];
+	if (!setter) throw new Error(`Computed property "${key}" is readonly`);
+	setter(value);
+}
+function setWithSegments(target, segments, value) {
+	let current = target;
+	for (let i = 0; i < segments.length - 1; i++) {
+		const key = segments[i];
+		if (current[key] == null || typeof current[key] !== "object") current[key] = {};
+		current = current[key];
+	}
+	current[segments[segments.length - 1]] = value;
+}
+function setByPath(state, computedRefs, computedSetters, segments, value) {
+	if (!segments.length) return;
+	const [head, ...rest] = segments;
+	if (!rest.length) {
+		if (computedRefs[head]) setComputedValue$1(computedSetters, head, value);
+		else state[head] = value;
+		return;
+	}
+	if (computedRefs[head]) {
+		setComputedValue$1(computedSetters, head, value);
+		return;
+	}
+	if (state[head] == null || typeof state[head] !== "object") state[head] = {};
+	setWithSegments(state[head], rest, value);
+}
+function getFromPath(target, segments) {
+	return segments.reduce((acc, segment) => {
+		if (acc == null) return acc;
+		return acc[segment];
+	}, target);
+}
+function defaultParser(event) {
+	if (event == null) return event;
+	if (typeof event === "object") {
+		if ("detail" in event && event.detail && "value" in event.detail) return event.detail.value;
+		if ("target" in event && event.target && "value" in event.target) return event.target.value;
+	}
+	return event;
+}
+function createBindModel(publicInstance, state, computedRefs, computedSetters) {
+	const bindModel = (path, bindingOptions) => {
+		const segments = toPathSegments(path);
+		if (!segments.length) throw new Error("bindModel requires a non-empty path");
+		const resolveValue = () => getFromPath(publicInstance, segments);
+		const assignValue = (value) => {
+			setByPath(state, computedRefs, computedSetters, segments, value);
+		};
+		const defaultOptions = {
+			event: "input",
+			valueProp: "value",
+			parser: defaultParser,
+			formatter: (value) => value,
+			...bindingOptions
+		};
+		return {
+			get value() {
+				return resolveValue();
+			},
+			set value(nextValue) {
+				assignValue(nextValue);
+			},
+			update(nextValue) {
+				assignValue(nextValue);
+			},
+			model(modelOptions) {
+				const merged = {
+					...defaultOptions,
+					...modelOptions
+				};
+				const handlerKey = `on${capitalize(merged.event)}`;
+				const payload = { [merged.valueProp]: merged.formatter(resolveValue()) };
+				payload[handlerKey] = (event) => {
+					assignValue(merged.parser(event));
+				};
+				return payload;
+			}
+		};
+	};
+	return bindModel;
 }
 
+//#endregion
+//#region src/runtime/diff.ts
 function isPlainObject(value) {
-  if (Object.prototype.toString.call(value) !== "[object Object]") {
-    return false;
-  }
-  const proto = Object.getPrototypeOf(value);
-  return proto === null || proto === Object.prototype;
+	if (Object.prototype.toString.call(value) !== "[object Object]") return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === null || proto === Object.prototype;
 }
 function toPlain(value, seen = /* @__PURE__ */ new WeakMap()) {
-  const unwrapped = unref(value);
-  if (typeof unwrapped !== "object" || unwrapped === null) {
-    return unwrapped;
-  }
-  const raw = isReactive(unwrapped) ? toRaw(unwrapped) : unwrapped;
-  if (seen.has(raw)) {
-    return seen.get(raw);
-  }
-  if (Array.isArray(raw)) {
-    const arr = [];
-    seen.set(raw, arr);
-    raw.forEach((item, index) => {
-      arr[index] = toPlain(item, seen);
-    });
-    return arr;
-  }
-  const output = {};
-  seen.set(raw, output);
-  Object.keys(raw).forEach((key) => {
-    output[key] = toPlain(raw[key], seen);
-  });
-  return output;
+	const unwrapped = unref(value);
+	if (typeof unwrapped !== "object" || unwrapped === null) return unwrapped;
+	const raw = isReactive(unwrapped) ? toRaw(unwrapped) : unwrapped;
+	if (seen.has(raw)) return seen.get(raw);
+	if (Array.isArray(raw)) {
+		const arr = [];
+		seen.set(raw, arr);
+		raw.forEach((item, index) => {
+			arr[index] = toPlain(item, seen);
+		});
+		return arr;
+	}
+	const output = {};
+	seen.set(raw, output);
+	Object.keys(raw).forEach((key) => {
+		output[key] = toPlain(raw[key], seen);
+	});
+	return output;
 }
-function getFromPath(target, segments) {
-  return segments.reduce((acc, segment) => {
-    if (acc == null) {
-      return acc;
-    }
-    return acc[segment];
-  }, target);
+function isDeepEqual(a, b) {
+	if (Object.is(a, b)) return true;
+	if (Array.isArray(a) && Array.isArray(b)) return isArrayEqual(a, b);
+	if (isPlainObject(a) && isPlainObject(b)) return isPlainObjectEqual(a, b);
+	return false;
 }
-function setWithSegments(target, segments, value) {
-  let current = target;
-  for (let i = 0; i < segments.length - 1; i++) {
-    const key = segments[i];
-    if (current[key] == null || typeof current[key] !== "object") {
-      current[key] = {};
-    }
-    current = current[key];
-  }
-  current[segments[segments.length - 1]] = value;
+function isArrayEqual(a, b) {
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) if (!isDeepEqual(a[i], b[i])) return false;
+	return true;
 }
-function setComputedValue(setters, key, value) {
-  const setter = setters[key];
-  if (!setter) {
-    throw new Error(`Computed property "${key}" is readonly`);
-  }
-  setter(value);
+function isPlainObjectEqual(a, b) {
+	const aKeys = Object.keys(a);
+	const bKeys = Object.keys(b);
+	if (aKeys.length !== bKeys.length) return false;
+	for (const key of aKeys) {
+		if (!Object.prototype.hasOwnProperty.call(b, key)) return false;
+		if (!isDeepEqual(a[key], b[key])) return false;
+	}
+	return true;
 }
-function setByPath(state, computedRefs, computedSetters, segments, value) {
-  if (!segments.length) {
-    return;
-  }
-  const [head, ...rest] = segments;
-  if (!rest.length) {
-    if (computedRefs[head]) {
-      setComputedValue(computedSetters, head, value);
-    } else {
-      state[head] = value;
-    }
-    return;
-  }
-  if (computedRefs[head]) {
-    setComputedValue(computedSetters, head, value);
-    return;
-  }
-  if (state[head] == null || typeof state[head] !== "object") {
-    state[head] = {};
-  }
-  setWithSegments(state[head], rest, value);
+function normalizeSetDataValue(value) {
+	return value === void 0 ? null : value;
 }
-function defaultParser(event) {
-  if (event == null) {
-    return event;
-  }
-  if (typeof event === "object") {
-    if ("detail" in event && event.detail && "value" in event.detail) {
-      return event.detail.value;
-    }
-    if ("target" in event && event.target && "value" in event.target) {
-      return event.target.value;
-    }
-  }
-  return event;
+function assignNestedDiff(prev, next, path, output) {
+	if (isDeepEqual(prev, next)) return;
+	if (isPlainObject(prev) && isPlainObject(next)) {
+		new Set([...Object.keys(prev), ...Object.keys(next)]).forEach((key) => {
+			if (!Object.prototype.hasOwnProperty.call(next, key)) {
+				output[`${path}.${key}`] = null;
+				return;
+			}
+			assignNestedDiff(prev[key], next[key], `${path}.${key}`, output);
+		});
+		return;
+	}
+	if (Array.isArray(prev) && Array.isArray(next)) {
+		if (!isArrayEqual(prev, next)) output[path] = normalizeSetDataValue(next);
+		return;
+	}
+	output[path] = normalizeSetDataValue(next);
+}
+function diffSnapshots(prev, next) {
+	const diff = {};
+	new Set([...Object.keys(prev), ...Object.keys(next)]).forEach((key) => {
+		if (!Object.prototype.hasOwnProperty.call(next, key)) {
+			diff[key] = null;
+			return;
+		}
+		assignNestedDiff(prev[key], next[key], key, diff);
+	});
+	return diff;
+}
+
+//#endregion
+//#region src/runtime/hooks.ts
+let __currentInstance;
+function getCurrentInstance() {
+	return __currentInstance;
+}
+function setCurrentInstance(inst) {
+	__currentInstance = inst;
+}
+function ensureHookBucket(target) {
+	if (!target.__wevuHooks) target.__wevuHooks = Object.create(null);
+	return target.__wevuHooks;
+}
+function pushHook(target, name, handler, { single = false } = {}) {
+	const bucket = ensureHookBucket(target);
+	if (single) bucket[name] = handler;
+	else (bucket[name] ?? (bucket[name] = [])).push(handler);
+}
+function callHookList(target, name, args = []) {
+	const hooks = target.__wevuHooks;
+	if (!hooks) return;
+	const list = hooks[name];
+	if (!list) return;
+	const ctx = target.__wevu?.proxy ?? target;
+	if (Array.isArray(list)) for (const fn of list) try {
+		fn.apply(ctx, args);
+	} catch {}
+	else if (typeof list === "function") try {
+		list.apply(ctx, args);
+	} catch {}
+}
+function callHookReturn(target, name, args = []) {
+	const hooks = target.__wevuHooks;
+	if (!hooks) return;
+	const entry = hooks[name];
+	if (!entry) return;
+	const ctx = target.__wevu?.proxy ?? target;
+	if (typeof entry === "function") try {
+		return entry.apply(ctx, args);
+	} catch {
+		return;
+	}
+	if (Array.isArray(entry)) {
+		let out;
+		for (const fn of entry) try {
+			out = fn.apply(ctx, args);
+		} catch {}
+		return out;
+	}
+}
+function onAppShow(handler) {
+	if (!__currentInstance) throw new Error("onAppShow() must be called synchronously inside setup()");
+	pushHook(__currentInstance, "onAppShow", handler);
+}
+function onAppHide(handler) {
+	if (!__currentInstance) throw new Error("onAppHide() must be called synchronously inside setup()");
+	pushHook(__currentInstance, "onAppHide", handler);
+}
+function onAppError(handler) {
+	if (!__currentInstance) throw new Error("onAppError() must be called synchronously inside setup()");
+	pushHook(__currentInstance, "onAppError", handler);
+}
+function onShow(handler) {
+	if (!__currentInstance) throw new Error("onShow() must be called synchronously inside setup()");
+	pushHook(__currentInstance, "onShow", handler);
+}
+function onHide(handler) {
+	if (!__currentInstance) throw new Error("onHide() must be called synchronously inside setup()");
+	pushHook(__currentInstance, "onHide", handler);
+}
+function onUnload(handler) {
+	if (!__currentInstance) throw new Error("onUnload() must be called synchronously inside setup()");
+	pushHook(__currentInstance, "onUnload", handler);
+}
+function onReady(handler) {
+	if (!__currentInstance) throw new Error("onReady() must be called synchronously inside setup()");
+	pushHook(__currentInstance, "onReady", handler);
 }
+function onPageScroll(handler) {
+	if (!__currentInstance) throw new Error("onPageScroll() must be called synchronously inside setup()");
+	pushHook(__currentInstance, "onPageScroll", handler);
+}
+function onRouteDone(handler) {
+	if (!__currentInstance) throw new Error("onRouteDone() must be called synchronously inside setup()");
+	pushHook(__currentInstance, "onRouteDone", handler);
+}
+function onTabItemTap(handler) {
+	if (!__currentInstance) throw new Error("onTabItemTap() must be called synchronously inside setup()");
+	pushHook(__currentInstance, "onTabItemTap", handler);
+}
+function onSaveExitState(handler) {
+	if (!__currentInstance) throw new Error("onSaveExitState() must be called synchronously inside setup()");
+	pushHook(__currentInstance, "onSaveExitState", handler, { single: true });
+}
+function onShareAppMessage(handler) {
+	if (!__currentInstance) throw new Error("onShareAppMessage() must be called synchronously inside setup()");
+	pushHook(__currentInstance, "onShareAppMessage", handler, { single: true });
+}
+function onShareTimeline(handler) {
+	if (!__currentInstance) throw new Error("onShareTimeline() must be called synchronously inside setup()");
+	pushHook(__currentInstance, "onShareTimeline", handler, { single: true });
+}
+function onAddToFavorites(handler) {
+	if (!__currentInstance) throw new Error("onAddToFavorites() must be called synchronously inside setup()");
+	pushHook(__currentInstance, "onAddToFavorites", handler, { single: true });
+}
+/**
+* Vue 3 对齐：组件/页面已挂载，映射小程序 onReady
+*/
+function onMounted(handler) {
+	if (!__currentInstance) throw new Error("onMounted() must be called synchronously inside setup()");
+	pushHook(__currentInstance, "onReady", handler);
+}
+/**
+* Vue 3 对齐：组件/页面更新后触发。
+* 小程序没有专用 update 生命周期，这里在每次 setData 完成后调用。
+*/
+function onUpdated(handler) {
+	if (!__currentInstance) throw new Error("onUpdated() must be called synchronously inside setup()");
+	pushHook(__currentInstance, "__wevuOnUpdated", handler);
+}
+/**
+* Vue 3 对齐：卸载前触发。
+* 小程序无 before-unload 生命周期，setup 时同步执行以保持语义。
+*/
+function onBeforeUnmount(handler) {
+	if (!__currentInstance) throw new Error("onBeforeUnmount() must be called synchronously inside setup()");
+	handler();
+}
+/**
+* Vue 3 对齐：组件/页面卸载；映射到页面 onUnload 或组件 detached
+*/
+function onUnmounted(handler) {
+	if (!__currentInstance) throw new Error("onUnmounted() must be called synchronously inside setup()");
+	pushHook(__currentInstance, "onUnload", handler);
+}
+/**
+* Vue 3 对齐：挂载前；setup 时同步触发以模拟 beforeMount 语义
+*/
+function onBeforeMount(handler) {
+	if (!__currentInstance) throw new Error("onBeforeMount() must be called synchronously inside setup()");
+	handler();
+}
+/**
+* Vue 3 对齐：更新前；在每次 setData 前触发
+*/
+function onBeforeUpdate(handler) {
+	if (!__currentInstance) throw new Error("onBeforeUpdate() must be called synchronously inside setup()");
+	pushHook(__currentInstance, "__wevuOnBeforeUpdate", handler);
+}
+/**
+* Vue 3 对齐：错误捕获；映射到小程序 onError
+*/
+function onErrorCaptured(handler) {
+	if (!__currentInstance) throw new Error("onErrorCaptured() must be called synchronously inside setup()");
+	pushHook(__currentInstance, "onAppError", (err) => handler(err, __currentInstance, ""));
+}
+/**
+* Vue 3 对齐：组件激活；映射到小程序 onShow
+*/
+function onActivated(handler) {
+	if (!__currentInstance) throw new Error("onActivated() must be called synchronously inside setup()");
+	pushHook(__currentInstance, "onShow", handler);
+}
+/**
+* Vue 3 对齐：组件失活；映射到小程序 onHide
+*/
+function onDeactivated(handler) {
+	if (!__currentInstance) throw new Error("onDeactivated() must be called synchronously inside setup()");
+	pushHook(__currentInstance, "onHide", handler);
+}
+/**
+* Vue 3 对齐：服务端渲染前置钩子。
+* 小程序无此场景，保留空实现以保持 API 兼容。
+*/
+function onServerPrefetch(_handler) {
+	if (!__currentInstance) throw new Error("onServerPrefetch() must be called synchronously inside setup()");
+}
+function callUpdateHooks(target, phase) {
+	callHookList(target, phase === "before" ? "__wevuOnBeforeUpdate" : "__wevuOnUpdated");
+}
+
+//#endregion
+//#region src/runtime/register.ts
+function runSetupFunction(setup, props, context) {
+	if (typeof setup !== "function") return;
+	const runtimeContext = context?.runtime ?? {
+		methods: Object.create(null),
+		state: {},
+		proxy: {},
+		watch: () => () => {},
+		bindModel: () => {}
+	};
+	if (context) context.runtime = runtimeContext;
+	const finalContext = {
+		...context ?? {},
+		runtime: runtimeContext
+	};
+	return setup.length >= 2 ? setup(props, finalContext) : setup(finalContext);
+}
+function normalizeWatchDescriptor(descriptor, runtime, instance) {
+	if (typeof descriptor === "function") return {
+		handler: descriptor.bind(runtime.proxy),
+		options: {}
+	};
+	if (typeof descriptor === "string") {
+		const method = runtime.methods?.[descriptor] ?? instance[descriptor];
+		if (typeof method === "function") return {
+			handler: method.bind(runtime.proxy),
+			options: {}
+		};
+		return;
+	}
+	if (!descriptor || typeof descriptor !== "object") return;
+	const base = normalizeWatchDescriptor(descriptor.handler, runtime, instance);
+	if (!base) return;
+	const options = { ...base.options };
+	if (descriptor.immediate !== void 0) options.immediate = descriptor.immediate;
+	if (descriptor.deep !== void 0) options.deep = descriptor.deep;
+	return {
+		handler: base.handler,
+		options
+	};
+}
+function createPathGetter(target, path) {
+	const segments = path.split(".").map((segment) => segment.trim()).filter(Boolean);
+	if (!segments.length) return () => target;
+	return () => {
+		let current = target;
+		for (const segment of segments) {
+			if (current == null) return current;
+			current = current[segment];
+		}
+		return current;
+	};
+}
+function registerWatches(runtime, watchMap, instance) {
+	const stops = [];
+	const proxy = runtime.proxy;
+	for (const [expression, descriptor] of Object.entries(watchMap)) {
+		const normalized = normalizeWatchDescriptor(descriptor, runtime, instance);
+		if (!normalized) continue;
+		const getter = createPathGetter(proxy, expression);
+		const stop$1 = runtime.watch(getter, normalized.handler, normalized.options);
+		stops.push(stop$1);
+	}
+	return stops;
+}
+function mountRuntimeInstance(target, runtimeApp, watchMap, setup) {
+	const runtime = runtimeApp.mount({ setData(payload) {
+		if (typeof target.setData === "function") target.setData(payload);
+	} });
+	const runtimeProxy = runtime?.proxy ?? {};
+	const runtimeState = runtime?.state ?? {};
+	if (!runtime?.methods) try {
+		runtime.methods = Object.create(null);
+	} catch {}
+	const runtimeMethods = runtime?.methods ?? Object.create(null);
+	const runtimeWatch = runtime?.watch ?? (() => () => {});
+	const runtimeBindModel = runtime?.bindModel ?? (() => {});
+	const runtimeWithDefaults = {
+		...runtime ?? {},
+		state: runtimeState,
+		proxy: runtimeProxy,
+		methods: runtimeMethods,
+		watch: runtimeWatch,
+		bindModel: runtimeBindModel
+	};
+	Object.defineProperty(target, "$wevu", {
+		value: runtimeWithDefaults,
+		configurable: true,
+		enumerable: false,
+		writable: false
+	});
+	target.__wevu = runtimeWithDefaults;
+	if (watchMap) {
+		const stops = registerWatches(runtimeWithDefaults, watchMap, target);
+		if (stops.length) target.__wevuWatchStops = stops;
+	}
+	if (setup) {
+		const props = target.properties || {};
+		const context = {
+			props,
+			runtime: runtimeWithDefaults,
+			state: runtimeState,
+			proxy: runtimeProxy,
+			bindModel: runtimeBindModel.bind(runtimeWithDefaults),
+			watch: runtimeWatch.bind(runtimeWithDefaults),
+			instance: target,
+			emit: (event, ...args) => {
+				if (typeof target.triggerEvent === "function") target.triggerEvent(event, ...args);
+			},
+			expose: (exposed) => {
+				target.__wevuExposed = exposed;
+			},
+			attrs: {}
+		};
+		setCurrentInstance(target);
+		try {
+			const result = runSetupFunction(setup, props, context);
+			if (result && typeof result === "object") Object.keys(result).forEach((key) => {
+				const val = result[key];
+				if (typeof val === "function") runtime.methods[key] = (...args) => val.apply(runtime.proxy, args);
+				else runtime.state[key] = val;
+			});
+		} finally {
+			setCurrentInstance(void 0);
+		}
+	}
+	try {
+		const methods = runtime.methods;
+		for (const name of Object.keys(methods)) if (typeof target[name] !== "function") target[name] = function bridged(...args) {
+			const bound = (this.$wevu?.methods)?.[name];
+			if (typeof bound === "function") return bound.apply(this.$wevu.proxy, args);
+		};
+	} catch {}
+	return runtime;
+}
+function teardownRuntimeInstance(target) {
+	const runtime = target.__wevu;
+	if (target.__wevuHooks) target.__wevuHooks = void 0;
+	const stops = target.__wevuWatchStops;
+	if (Array.isArray(stops)) for (const stop$1 of stops) try {
+		stop$1();
+	} catch {}
+	target.__wevuWatchStops = void 0;
+	if (runtime) runtime.unmount();
+	delete target.__wevu;
+	if ("$wevu" in target) delete target.$wevu;
+}
+function registerApp(runtimeApp, methods, watch$1, setup, mpOptions) {
+	if (typeof App !== "function") throw new TypeError("createApp requires the global App constructor to be available");
+	const methodNames = Object.keys(methods ?? {});
+	const appOptions = { ...mpOptions };
+	appOptions.globalData = appOptions.globalData ?? {};
+	const userOnLaunch = appOptions.onLaunch;
+	appOptions.onLaunch = function onLaunch(...args) {
+		mountRuntimeInstance(this, runtimeApp, watch$1, setup);
+		callHookList(this, "onAppLaunch", args);
+		if (typeof userOnLaunch === "function") userOnLaunch.apply(this, args);
+	};
+	const userOnShow = appOptions.onShow;
+	appOptions.onShow = function onShow$1(...args) {
+		callHookList(this, "onAppShow", args);
+		if (typeof userOnShow === "function") userOnShow.apply(this, args);
+	};
+	const userOnHide = appOptions.onHide;
+	appOptions.onHide = function onHide$1(...args) {
+		callHookList(this, "onAppHide", args);
+		if (typeof userOnHide === "function") userOnHide.apply(this, args);
+	};
+	const userOnError = appOptions.onError;
+	appOptions.onError = function onError(...args) {
+		callHookList(this, "onAppError", args);
+		if (typeof userOnError === "function") userOnError.apply(this, args);
+	};
+	for (const methodName of methodNames) {
+		const userMethod = appOptions[methodName];
+		appOptions[methodName] = function runtimeMethod(...args) {
+			const runtime = this.__wevu;
+			let result;
+			const bound = runtime?.methods?.[methodName];
+			if (bound) result = bound.apply(runtime.proxy, args);
+			if (typeof userMethod === "function") return userMethod.apply(this, args);
+			return result;
+		};
+	}
+	App(appOptions);
+}
+function registerPage(runtimeApp, methods, watch$1, setup, mpOptions, features) {
+	if (typeof Page !== "function") throw new TypeError("definePage requires the global Page constructor to be available");
+	const methodNames = Object.keys(methods ?? {});
+	const pageOptions = { ...mpOptions };
+	const userOnLoad = mpOptions.onLoad;
+	pageOptions.onLoad = function onLoad(...args) {
+		mountRuntimeInstance(this, runtimeApp, watch$1, setup);
+		callHookList(this, "onShow", args);
+		if (typeof userOnLoad === "function") userOnLoad.apply(this, args);
+	};
+	const userOnUnload = mpOptions.onUnload;
+	pageOptions.onUnload = function onUnload$1(...args) {
+		teardownRuntimeInstance(this);
+		if (typeof userOnUnload === "function") userOnUnload.apply(this, args);
+	};
+	const userOnShow = mpOptions.onShow;
+	pageOptions.onShow = function onShow$1(...args) {
+		callHookList(this, "onShow", args);
+		if (typeof userOnShow === "function") userOnShow.apply(this, args);
+	};
+	const userOnHide = mpOptions.onHide;
+	pageOptions.onHide = function onHide$1(...args) {
+		callHookList(this, "onHide", args);
+		if (typeof userOnHide === "function") userOnHide.apply(this, args);
+	};
+	const userOnReady = mpOptions.onReady;
+	pageOptions.onReady = function onReady$1(...args) {
+		callHookList(this, "onReady", args);
+		if (typeof userOnReady === "function") return userOnReady.apply(this, args);
+	};
+	const userOnSaveExitState = mpOptions.onSaveExitState;
+	pageOptions.onSaveExitState = function onSaveExitState$1(...args) {
+		const ret = callHookReturn(this, "onSaveExitState", args);
+		if (ret !== void 0) return ret;
+		if (typeof userOnSaveExitState === "function") return userOnSaveExitState.apply(this, args);
+	};
+	if (features?.listenPageScroll) {
+		const userOnPageScroll = mpOptions.onPageScroll;
+		pageOptions.onPageScroll = function onPageScroll$1(...args) {
+			callHookList(this, "onPageScroll", args);
+			if (typeof userOnPageScroll === "function") return userOnPageScroll.apply(this, args);
+		};
+	}
+	if (features?.enableShareAppMessage) {
+		const userOnShare = mpOptions.onShareAppMessage;
+		pageOptions.onShareAppMessage = function pageOnShareAppMessage(...args) {
+			const ret = callHookReturn(this, "onShareAppMessage", args);
+			if (ret !== void 0) return ret;
+			if (typeof userOnShare === "function") return userOnShare.apply(this, args);
+		};
+	}
+	if (features?.enableShareTimeline) {
+		const userOnShareTimeline = mpOptions.onShareTimeline;
+		pageOptions.onShareTimeline = function pageOnShareTimeline(...args) {
+			const ret = callHookReturn(this, "onShareTimeline", args);
+			if (ret !== void 0) return ret;
+			if (typeof userOnShareTimeline === "function") return userOnShareTimeline.apply(this, args);
+		};
+	}
+	if (features?.enableAddToFavorites) {
+		const userOnAddToFavorites = mpOptions.onAddToFavorites;
+		pageOptions.onAddToFavorites = function pageOnAddToFavorites(...args) {
+			const ret = callHookReturn(this, "onAddToFavorites", args);
+			if (ret !== void 0) return ret;
+			if (typeof userOnAddToFavorites === "function") return userOnAddToFavorites.apply(this, args);
+		};
+	}
+	for (const methodName of methodNames) {
+		const userMethod = mpOptions[methodName];
+		pageOptions[methodName] = function runtimeMethod(...args) {
+			const runtime = this.__wevu;
+			let result;
+			const bound = runtime?.methods?.[methodName];
+			if (bound) result = bound.apply(runtime.proxy, args);
+			if (typeof userMethod === "function") return userMethod.apply(this, args);
+			return result;
+		};
+	}
+	Page(pageOptions);
+}
+function registerComponent(runtimeApp, methods, watch$1, setup, mpOptions) {
+	const { methods: userMethods = {}, lifetimes: userLifetimes = {}, pageLifetimes: userPageLifetimes = {}, ...rest } = mpOptions;
+	const finalMethods = { ...userMethods };
+	const methodNames = Object.keys(methods ?? {});
+	for (const methodName of methodNames) {
+		const userMethod = finalMethods[methodName];
+		finalMethods[methodName] = function componentMethod(...args) {
+			const runtime = this.__wevu;
+			let result;
+			const bound = runtime?.methods?.[methodName];
+			if (bound) result = bound.apply(runtime.proxy, args);
+			if (typeof userMethod === "function") return userMethod.apply(this, args);
+			return result;
+		};
+	}
+	const wrapSpecial = (name) => {
+		const user = userLifetimes[name] ?? userPageLifetimes[name];
+		finalMethods[name] = function wrapped(...args) {
+			callHookList(this, name, args);
+			if (typeof user === "function") return user.apply(this, args);
+		};
+	};
+	wrapSpecial("onTabItemTap");
+	wrapSpecial("onRouteDone");
+	Component({
+		...rest,
+		lifetimes: {
+			...userLifetimes,
+			attached: function attached(...args) {
+				mountRuntimeInstance(this, runtimeApp, watch$1, setup);
+				if (typeof userLifetimes.attached === "function") userLifetimes.attached.apply(this, args);
+			},
+			ready: function ready(...args) {
+				callHookList(this, "onReady", args);
+				if (typeof userLifetimes.ready === "function") userLifetimes.ready.apply(this, args);
+			},
+			detached: function detached(...args) {
+				teardownRuntimeInstance(this);
+				if (typeof userLifetimes.detached === "function") userLifetimes.detached.apply(this, args);
+			}
+		},
+		pageLifetimes: {
+			...userPageLifetimes,
+			show: function show(...args) {
+				callHookList(this, "onShow", args);
+				if (typeof userPageLifetimes.show === "function") userPageLifetimes.show.apply(this, args);
+			},
+			hide: function hide(...args) {
+				callHookList(this, "onHide", args);
+				if (typeof userPageLifetimes.hide === "function") userPageLifetimes.hide.apply(this, args);
+			}
+		},
+		methods: finalMethods
+	});
+}
+
+//#endregion
+//#region src/runtime/app.ts
 function createApp(options) {
-  return {
-    mount(adapter) {
-      const dataFn = options.data ?? (() => ({}));
-      const rawState = dataFn();
-      if (!isReactive(rawState) && !isPlainObject(rawState)) {
-        throw new Error("data() must return a plain object");
-      }
-      const state = reactive(rawState);
-      const computedDefs = options.computed ?? {};
-      const methodDefs = options.methods ?? {};
-      const computedRefs = /* @__PURE__ */ Object.create(null);
-      const computedSetters = /* @__PURE__ */ Object.create(null);
-      const boundMethods = {};
-      let mounted = true;
-      let latestSnapshot = {};
-      const stopHandles = [];
-      const computedProxy = new Proxy(
-        {},
-        {
-          get(_target, key) {
-            if (typeof key === "string" && computedRefs[key]) {
-              return computedRefs[key].value;
-            }
-            return void 0;
-          },
-          has(_target, key) {
-            return typeof key === "string" && Boolean(computedRefs[key]);
-          },
-          ownKeys() {
-            return Object.keys(computedRefs);
-          },
-          getOwnPropertyDescriptor(_target, key) {
-            if (typeof key === "string" && computedRefs[key]) {
-              return {
-                configurable: true,
-                enumerable: true,
-                value: computedRefs[key].value
-              };
-            }
-            return void 0;
-          }
-        }
-      );
-      const publicInstance = new Proxy(state, {
-        get(target, key, receiver) {
-          if (typeof key === "string") {
-            if (key === "$state") {
-              return state;
-            }
-            if (key === "$computed") {
-              return computedProxy;
-            }
-            if (Object.prototype.hasOwnProperty.call(boundMethods, key)) {
-              return boundMethods[key];
-            }
-            if (computedRefs[key]) {
-              return computedRefs[key].value;
-            }
-          }
-          return Reflect.get(target, key, receiver);
-        },
-        set(target, key, value, receiver) {
-          if (typeof key === "string" && computedRefs[key]) {
-            setComputedValue(computedSetters, key, value);
-            return true;
-          }
-          return Reflect.set(target, key, value, receiver);
-        },
-        has(target, key) {
-          if (typeof key === "string" && (computedRefs[key] || Object.prototype.hasOwnProperty.call(boundMethods, key))) {
-            return true;
-          }
-          return Reflect.has(target, key);
-        },
-        ownKeys(target) {
-          const keys = /* @__PURE__ */ new Set();
-          Reflect.ownKeys(target).forEach((key) => {
-            keys.add(key);
-          });
-          Object.keys(boundMethods).forEach((key) => keys.add(key));
-          Object.keys(computedRefs).forEach((key) => keys.add(key));
-          return Array.from(keys);
-        },
-        getOwnPropertyDescriptor(target, key) {
-          if (Reflect.has(target, key)) {
-            return Object.getOwnPropertyDescriptor(target, key);
-          }
-          if (typeof key === "string") {
-            if (computedRefs[key]) {
-              return {
-                configurable: true,
-                enumerable: true,
-                get() {
-                  return computedRefs[key].value;
-                },
-                set(value) {
-                  setComputedValue(computedSetters, key, value);
-                }
-              };
-            }
-            if (Object.prototype.hasOwnProperty.call(boundMethods, key)) {
-              return {
-                configurable: true,
-                enumerable: false,
-                value: boundMethods[key]
-              };
-            }
-          }
-          return void 0;
-        }
-      });
-      Object.keys(methodDefs).forEach((key) => {
-        const handler = methodDefs[key];
-        if (typeof handler === "function") {
-          boundMethods[key] = ((...args) => handler.apply(publicInstance, args));
-        }
-      });
-      Object.keys(computedDefs).forEach((key) => {
-        const definition = computedDefs[key];
-        if (typeof definition === "function") {
-          computedRefs[key] = computed(() => definition.call(publicInstance));
-        } else {
-          const getter = definition.get?.bind(publicInstance);
-          if (!getter) {
-            throw new Error(`Computed property "${key}" requires a getter`);
-          }
-          const setter = definition.set?.bind(publicInstance);
-          if (setter) {
-            computedSetters[key] = setter;
-            computedRefs[key] = computed({
-              get: getter,
-              set: setter
-            });
-          } else {
-            computedRefs[key] = computed(getter);
-          }
-        }
-      });
-      const currentAdapter = adapter ?? { setData: () => {
-      } };
-      const collectSnapshot = () => {
-        const plain = toPlain(state);
-        Object.keys(computedRefs).forEach((key) => {
-          plain[key] = toPlain(computedRefs[key].value);
-        });
-        return plain;
-      };
-      const job = () => {
-        if (!mounted) {
-          return;
-        }
-        const snapshot = collectSnapshot();
-        latestSnapshot = snapshot;
-        if (typeof currentAdapter.setData === "function") {
-          currentAdapter.setData(snapshot);
-        }
-      };
-      const tracker = effect(
-        () => {
-          traverse(state);
-          Object.keys(computedRefs).forEach((key) => computedRefs[key].value);
-        },
-        {
-          scheduler: () => queueJob(job)
-        }
-      );
-      job();
-      stopHandles.push(() => stop(tracker));
-      function registerWatch(source, cb, watchOptions) {
-        const stopHandle = watch(source, (value, oldValue) => cb(value, oldValue), watchOptions);
-        stopHandles.push(stopHandle);
-        return () => {
-          stopHandle();
-          const index = stopHandles.indexOf(stopHandle);
-          if (index >= 0) {
-            stopHandles.splice(index, 1);
-          }
-        };
-      }
-      const bindModel = (path, bindingOptions) => {
-        const segments = toPathSegments(path);
-        if (!segments.length) {
-          throw new Error("bindModel requires a non-empty path");
-        }
-        const resolveValue = () => getFromPath(publicInstance, segments);
-        const assignValue = (value) => {
-          setByPath(state, computedRefs, computedSetters, segments, value);
-        };
-        const defaultOptions = {
-          event: "input",
-          valueProp: "value",
-          parser: defaultParser,
-          formatter: (value) => value,
-          ...bindingOptions
-        };
-        return {
-          get value() {
-            return resolveValue();
-          },
-          set value(nextValue) {
-            assignValue(nextValue);
-          },
-          update(nextValue) {
-            assignValue(nextValue);
-          },
-          model(modelOptions) {
-            const merged = {
-              ...defaultOptions,
-              ...modelOptions
-            };
-            const handlerKey = `on${capitalize(merged.event)}`;
-            const payload = {
-              [merged.valueProp]: merged.formatter(resolveValue())
-            };
-            payload[handlerKey] = (event) => {
-              const parsed = merged.parser(event);
-              assignValue(parsed);
-            };
-            return payload;
-          }
-        };
-      };
-      const unmount = () => {
-        if (!mounted) {
-          return;
-        }
-        mounted = false;
-        stopHandles.forEach((handle) => {
-          try {
-            handle();
-          } catch {
-          }
-        });
-        stopHandles.length = 0;
-      };
-      return {
-        get state() {
-          return state;
-        },
-        get proxy() {
-          return publicInstance;
-        },
-        get methods() {
-          return boundMethods;
-        },
-        get computed() {
-          return computedProxy;
-        },
-        get adapter() {
-          return currentAdapter;
-        },
-        bindModel,
-        watch: registerWatch,
-        snapshot: () => ({ ...latestSnapshot }),
-        unmount
-      };
-    }
-  };
+	const { data, computed: computedOptions, methods, watch: appWatch, setup: appSetup, ...mpOptions } = options;
+	const resolvedMethods = methods ?? {};
+	const resolvedComputed = computedOptions ?? {};
+	const installedPlugins = /* @__PURE__ */ new Set();
+	const appConfig = { globalProperties: {} };
+	const runtimeApp = {
+		mount(adapter) {
+			const state = reactive((data ?? (() => ({})))());
+			const computedDefs = resolvedComputed;
+			const methodDefs = resolvedMethods;
+			const computedRefs = Object.create(null);
+			const computedSetters = Object.create(null);
+			const boundMethods = {};
+			let mounted = true;
+			let latestSnapshot = {};
+			const stopHandles = [];
+			const computedProxy = new Proxy({}, {
+				get(_target, key) {
+					if (typeof key === "string" && computedRefs[key]) return computedRefs[key].value;
+				},
+				has(_target, key) {
+					return typeof key === "string" && Boolean(computedRefs[key]);
+				},
+				ownKeys() {
+					return Object.keys(computedRefs);
+				},
+				getOwnPropertyDescriptor(_target, key) {
+					if (typeof key === "string" && computedRefs[key]) return {
+						configurable: true,
+						enumerable: true,
+						value: computedRefs[key].value
+					};
+				}
+			});
+			const publicInstance = new Proxy(state, {
+				get(target, key, receiver) {
+					if (typeof key === "string") {
+						if (key === "$state") return state;
+						if (key === "$computed") return computedProxy;
+						if (Object.prototype.hasOwnProperty.call(boundMethods, key)) return boundMethods[key];
+						if (computedRefs[key]) return computedRefs[key].value;
+						if (Object.prototype.hasOwnProperty.call(appConfig.globalProperties, key)) return appConfig.globalProperties[key];
+					}
+					return Reflect.get(target, key, receiver);
+				},
+				set(target, key, value, receiver) {
+					if (typeof key === "string" && computedRefs[key]) {
+						setComputedValue(computedSetters, key, value);
+						return true;
+					}
+					return Reflect.set(target, key, value, receiver);
+				},
+				has(target, key) {
+					if (typeof key === "string" && (computedRefs[key] || Object.prototype.hasOwnProperty.call(boundMethods, key))) return true;
+					return Reflect.has(target, key);
+				},
+				ownKeys(target) {
+					const keys = /* @__PURE__ */ new Set();
+					Reflect.ownKeys(target).forEach((key) => {
+						keys.add(key);
+					});
+					Object.keys(boundMethods).forEach((key) => keys.add(key));
+					Object.keys(computedRefs).forEach((key) => keys.add(key));
+					return Array.from(keys);
+				},
+				getOwnPropertyDescriptor(target, key) {
+					if (Reflect.has(target, key)) return Object.getOwnPropertyDescriptor(target, key);
+					if (typeof key === "string") {
+						if (computedRefs[key]) return {
+							configurable: true,
+							enumerable: true,
+							get() {
+								return computedRefs[key].value;
+							},
+							set(value) {
+								setComputedValue(computedSetters, key, value);
+							}
+						};
+						if (Object.prototype.hasOwnProperty.call(boundMethods, key)) return {
+							configurable: true,
+							enumerable: false,
+							value: boundMethods[key]
+						};
+					}
+				}
+			});
+			Object.keys(methodDefs).forEach((key) => {
+				const handler = methodDefs[key];
+				if (typeof handler === "function") boundMethods[key] = (...args) => handler.apply(publicInstance, args);
+			});
+			Object.keys(computedDefs).forEach((key) => {
+				const definition = computedDefs[key];
+				if (typeof definition === "function") computedRefs[key] = computed(() => definition.call(publicInstance));
+				else {
+					const getter = definition.get?.bind(publicInstance);
+					if (!getter) throw new Error(`Computed property "${key}" requires a getter`);
+					const setter = definition.set?.bind(publicInstance);
+					if (setter) {
+						computedSetters[key] = setter;
+						computedRefs[key] = computed({
+							get: getter,
+							set: setter
+						});
+					} else computedRefs[key] = computed(getter);
+				}
+			});
+			const currentAdapter = adapter ?? { setData: () => {} };
+			const collectSnapshot = () => {
+				const plain = toPlain(state);
+				Object.keys(computedRefs).forEach((key) => {
+					plain[key] = toPlain(computedRefs[key].value);
+				});
+				return plain;
+			};
+			const job = () => {
+				if (!mounted) return;
+				const snapshot = collectSnapshot();
+				const diff = diffSnapshots(latestSnapshot, snapshot);
+				latestSnapshot = snapshot;
+				if (!Object.keys(diff).length) return;
+				if (typeof currentAdapter.setData === "function") {
+					const result = currentAdapter.setData(diff);
+					if (result && typeof result.then === "function") result.catch(() => {});
+				}
+			};
+			const tracker = effect(() => {
+				touchReactive(state);
+				Object.keys(computedRefs).forEach((key) => computedRefs[key].value);
+			}, { scheduler: () => queueJob(job) });
+			job();
+			stopHandles.push(() => stop(tracker));
+			function registerWatch(source, cb, watchOptions) {
+				const stopHandle = watch(source, (value, oldValue) => cb(value, oldValue), watchOptions);
+				stopHandles.push(stopHandle);
+				return () => {
+					stopHandle();
+					const index = stopHandles.indexOf(stopHandle);
+					if (index >= 0) stopHandles.splice(index, 1);
+				};
+			}
+			const bindModel = createBindModel(publicInstance, state, computedRefs, computedSetters);
+			const unmount = () => {
+				if (!mounted) return;
+				mounted = false;
+				stopHandles.forEach((handle) => {
+					try {
+						handle();
+					} catch {}
+				});
+				stopHandles.length = 0;
+			};
+			return {
+				get state() {
+					return state;
+				},
+				get proxy() {
+					return publicInstance;
+				},
+				get methods() {
+					return boundMethods;
+				},
+				get computed() {
+					return computedProxy;
+				},
+				get adapter() {
+					return currentAdapter;
+				},
+				bindModel,
+				watch: registerWatch,
+				snapshot: () => ({ ...latestSnapshot }),
+				unmount
+			};
+		},
+		use(plugin, ...options$1) {
+			if (!plugin || installedPlugins.has(plugin)) return runtimeApp;
+			installedPlugins.add(plugin);
+			if (typeof plugin === "function") plugin(runtimeApp, ...options$1);
+			else if (typeof plugin.install === "function") plugin.install(runtimeApp, ...options$1);
+			else throw new TypeError("A plugin must be a function or an object with an install method");
+			return runtimeApp;
+		},
+		config: appConfig
+	};
+	if (typeof globalThis.App === "function") registerApp(runtimeApp, methods ?? {}, appWatch, appSetup, mpOptions);
+	return runtimeApp;
+}
+function setComputedValue(setters, key, value) {
+	const setter = setters[key];
+	if (!setter) throw new Error(`Computed property "${key}" is readonly`);
+	setter(value);
+}
+
+//#endregion
+//#region src/runtime/define.ts
+/**
+* 按 Vue 3 风格定义一个小程序组件（始终注册为 Component，页面请用 definePage）。
+*
+* @param options 组件定义项
+* @returns 可手动注册的组件定义
+*
+* @example
+* ```ts
+* defineComponent({
+*   data: () => ({ count: 0 }),
+*   setup() {
+*     onMounted(() => console.log('mounted'))
+*   }
+* })
+* ```
+*/
+function defineComponent(options) {
+	const { data, computed: computed$1, methods, watch: watch$1, setup, props, ...mpOptions } = options;
+	const mpOptionsWithProps = normalizeProps(mpOptions, props);
+	const runtimeApp = createApp({
+		data,
+		computed: computed$1,
+		methods
+	});
+	const setupWrapper = (ctx) => {
+		const result = runSetupFunction(setup, ctx?.props ?? {}, ctx);
+		if (result) applySetupResult(ctx.runtime, ctx.instance, result);
+	};
+	const componentOptions = {
+		data,
+		computed: computed$1,
+		methods,
+		watch: watch$1,
+		setup: setupWrapper,
+		mpOptions: mpOptionsWithProps
+	};
+	registerComponent(runtimeApp, methods ?? {}, watch$1, setupWrapper, mpOptionsWithProps);
+	return {
+		__wevu_runtime: runtimeApp,
+		__wevu_options: componentOptions
+	};
+}
+/**
+* 按 Vue 3 风格定义一个小程序页面
+*
+* @param options 页面定义
+* @param features 页面特性（例如 listenPageScroll、enableShareAppMessage 等）
+* @returns 页面定义
+*
+* @example
+* ```ts
+* definePage({
+*   data: () => ({ count: 0 }),
+*   setup() {
+*     const count = ref(0)
+*     onMounted(() => console.log('page mounted'))
+*     return { count }
+*   }
+* }, {
+*   listenPageScroll: true,
+*   enableShareAppMessage: true
+* })
+* ```
+*/
+function definePage(options, features) {
+	const { data, computed: computed$1, methods, watch: watch$1, setup, props: _props, ...mpOptions } = options;
+	const runtimeApp = createApp({
+		data,
+		computed: computed$1,
+		methods
+	});
+	const setupWrapper = (ctx) => {
+		const result = runSetupFunction(setup, ctx?.props ?? {}, ctx);
+		if (result) applySetupResult(ctx.runtime, ctx.instance, result);
+	};
+	const componentOptions = {
+		type: "page",
+		data,
+		computed: computed$1,
+		methods,
+		watch: watch$1,
+		setup: setupWrapper,
+		mpOptions,
+		features
+	};
+	registerPage(runtimeApp, methods ?? {}, watch$1, setupWrapper, mpOptions, features);
+	return {
+		mount: () => {},
+		__wevu_runtime: runtimeApp,
+		__wevu_options: componentOptions
+	};
+}
+function applySetupResult(runtime, _target, result) {
+	const methods = runtime?.methods ?? Object.create(null);
+	const state = runtime?.state ?? Object.create(null);
+	if (runtime && !runtime.methods) try {
+		runtime.methods = methods;
+	} catch {}
+	if (runtime && !runtime.state) try {
+		runtime.state = state;
+	} catch {}
+	Object.keys(result).forEach((key) => {
+		const val = result[key];
+		if (typeof val === "function") methods[key] = (...args) => val.apply(runtime?.proxy ?? runtime, args);
+		else state[key] = val;
+	});
+	if (runtime) {
+		runtime.methods = runtime.methods ?? methods;
+		runtime.state = runtime.state ?? state;
+	}
+}
+/**
+* 从 Vue SFC 选项创建 wevu 组件，供 weapp-vite 编译产物直接调用的兼容入口。
+*
+* @param options 组件选项，可能包含小程序特有的 properties
+*/
+function createWevuComponent(options) {
+	const { properties, props, ...restOptions } = options;
+	defineComponent(normalizeProps(restOptions, props, properties));
+}
+function normalizeProps(baseOptions, props, explicitProperties) {
+	if (explicitProperties || !props) return {
+		...baseOptions,
+		...explicitProperties ? { properties: explicitProperties } : {}
+	};
+	const properties = {};
+	Object.entries(props).forEach(([key, definition]) => {
+		if (definition === null || definition === void 0) return;
+		if (Array.isArray(definition) || typeof definition === "function") {
+			properties[key] = { type: definition };
+			return;
+		}
+		if (typeof definition === "object") {
+			const propOptions = {};
+			if ("type" in definition && definition.type !== void 0) propOptions.type = definition.type;
+			const defaultValue = "default" in definition ? definition.default : definition.value;
+			if (defaultValue !== void 0) propOptions.value = typeof defaultValue === "function" ? defaultValue() : defaultValue;
+			properties[key] = propOptions;
+		}
+	});
+	return {
+		...baseOptions,
+		properties
+	};
+}
+
+//#endregion
+//#region src/runtime/provide.ts
+const PROVIDE_SCOPE_KEY = Symbol("wevu.provideScope");
+const __wevuGlobalProvideStore = /* @__PURE__ */ new Map();
+/**
+* 在组件上下文中向后代注入值（与 Vue 3 行为兼容），若没有当前实例则回落到全局存储。
+*
+* @param key 注入键，可为字符串、Symbol 或对象
+* @param value 提供的值
+*
+* @example
+* ```ts
+* defineComponent({
+*   setup() {
+*     provide(TOKEN_KEY, { data: 'value' })
+*   }
+* })
+* ```
+*/
+function provide(key, value) {
+	const instance = getCurrentInstance();
+	if (instance) {
+		let scope = instance[PROVIDE_SCOPE_KEY];
+		if (!scope) {
+			scope = /* @__PURE__ */ new Map();
+			instance[PROVIDE_SCOPE_KEY] = scope;
+		}
+		scope.set(key, value);
+	} else __wevuGlobalProvideStore.set(key, value);
+}
+/**
+* 从祖先组件（或全局存储）读取提供的值。
+*
+* @param key 注入键，需与 provide 使用的键保持一致
+* @param defaultValue 未找到提供者时的默认值
+* @returns 匹配到的值或默认值
+*
+* @example
+* ```ts
+* defineComponent({
+*   setup() {
+*     const data = inject(TOKEN_KEY)
+*     const value = inject('key', 'default')
+*   }
+* })
+* ```
+*/
+function inject(key, defaultValue) {
+	const instance = getCurrentInstance();
+	if (instance) {
+		let current = instance;
+		while (current) {
+			const scope = current[PROVIDE_SCOPE_KEY];
+			if (scope && scope.has(key)) return scope.get(key);
+			current = null;
+		}
+	}
+	if (__wevuGlobalProvideStore.has(key)) return __wevuGlobalProvideStore.get(key);
+	if (arguments.length >= 2) return defaultValue;
+	throw new Error(`wevu.inject: no value found for key`);
+}
+/**
+* 全局注入值，适用于组件外部调用场景。
+*/
+function provideGlobal(key, value) {
+	__wevuGlobalProvideStore.set(key, value);
+}
+/**
+* 从全局存储读取值，适用于组件外部调用场景。
+*/
+function injectGlobal(key, defaultValue) {
+	if (__wevuGlobalProvideStore.has(key)) return __wevuGlobalProvideStore.get(key);
+	if (arguments.length >= 2) return defaultValue;
+	throw new Error(`injectGlobal() no matching provider for key: ${String(key)}`);
 }
 
-export { computed, createApp, effect, isReactive, isRef, nextTick, reactive, ref, stop, toRaw, traverse, unref, watch };
+//#endregion
+export { callHookList, callHookReturn, callUpdateHooks, computed, createApp, createStore, createWevuComponent, defineComponent, definePage, defineStore, effect, getCurrentInstance, getDeepWatchStrategy, inject, injectGlobal, isRaw, isReactive, isRef, isShallowReactive, isShallowRef, markRaw, mountRuntimeInstance, nextTick, onActivated, onAddToFavorites, onAppError, onAppHide, onAppShow, onBeforeMount, onBeforeUnmount, onBeforeUpdate, onDeactivated, onErrorCaptured, onHide, onMounted, onPageScroll, onReady, onRouteDone, onSaveExitState, onServerPrefetch, onShareAppMessage, onShareTimeline, onShow, onTabItemTap, onUnload, onUnmounted, onUpdated, provide, provideGlobal, reactive, readonly, ref, registerApp, registerComponent, registerPage, runSetupFunction, setCurrentInstance, setDeepWatchStrategy, shallowReactive, shallowRef, stop, storeToRefs, teardownRuntimeInstance, toRaw, toRef, toRefs, touchReactive, traverse, triggerRef, unref, watch, watchEffect };