@rue-js/runtime-vapor 0.0.27 → 0.0.28

package/pkg/rue_runtime_vapor.d.ts

@@ -0,0 +1,1982 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * useEffect：模拟 React 的效果钩子
+ *
+ * - 依赖数组采用 `watch([...])` 的统一侦听底层实现
+ * - 逐项浅比较（`Object.is`）；可通过 `options.equals(prev, next)` 自定义比较
+ * - 返回清理函数将通过 `onCleanup()` 注册，在下一次依赖变化重跑前或侦听被处置时执行
+ *
+ * 示例：
+ * ```ts
+ * useEffect(() => {
+ *   const timer = setInterval(() => {}, 1000)
+ *   return () => clearInterval(timer)
+ * }, [])
+ *
+ * useEffect(() => {
+ *   console.log('count =', count.value)
+ * }, [() => count.value])
+ * ```
+ */
+export function useEffect(
+  effect: () => void | (() => void),
+  deps?: any[] | null,
+  options?: { equals?: Equals<T>; scheduler?: (run: () => void) => void } | null,
+): void;
+
+
+
+/**
+ * useSignal：等价于 `useState(initial, { kind: 'signal', ...options })`
+ *
+ * 用途：
+ * - 以“底层信号句柄”的形式管理状态，适合需要精细控制 `get/set/update/setPath/peek` 的场景
+ * - 支持 `equals(prev, next)` 自定义等值比较，返回 `true` 表示不触发订阅者
+ *
+ * 示例：
+ * const [sig, setSig] = useSignal({ a: 1 })
+ * console.log(sig.get())       // { a: 1 }
+ * setSig({ a: 2 })             // 触发订阅者
+ * setSig(h => ({ a: h.peek().a + 1 })) // { a: 3 }
+ * sig.setPath('a', 4)
+ * console.log(sig.get())       // { a: 4 }
+ */
+export function useSignal<T extends Primitive>(
+  initial: T | (() => T),
+  options?: UseStateOptions<T>,
+): [SignalHandle<Widen<T>>, (v: Widen<T> | ((sig: SignalHandle<Widen<T>>) => Widen<T> | void)) => void]
+export function useSignal<T extends object | Function>(
+  initial: T | (() => T),
+  options?: UseStateOptions<T>,
+): [SignalHandle<T>, (v: T | ((sig: SignalHandle<T>) => T | void)) => void]
+
+
+
+/**
+ * 调试工具：判断对象是否为 reactive 代理
+ */
+export function isReactive(obj: any): boolean;
+
+
+
+/**
+ * useCallback：根据依赖数组缓存回调函数的引用
+ */
+export function useCallback<T extends (...args: any[]) => any>(fn: T, deps: any[]): T;
+
+
+
+/**
+ * unref：若参数是 ref，返回其 .value；否则原样返回
+ */
+export function unref<T = any>(obj: any): T;
+ 
+
+
+/**
+ * 创建带选项的信号
+ * options.equals: Function(prev, next) -> bool，返回 true 表示值相等（不触发）
+ * 示例（JavaScript）：
+ * ```javascript
+ * const count = signal(0);
+ * createEffect(() => {
+ *   console.log('count =', count.get());
+ * });
+ * count.set(1); // 触发 effect
+ *
+ * const eq = (prev, next) => prev === next;
+ * const s = signal(0, { equals: eq });
+ * s.set(0); // 不触发，因为 equals 返回 true（相等）
+ * s.set(2); // 触发订阅者
+ * ```
+ */
+export function signal<T = any>(
+  initial: T,
+  options?: { equals?: Equals<T> },
+  forceGlobal?: boolean,
+): SignalHandle<T>;
+
+
+
+/**
+ * 调试工具：获取 reactive 代理背后的原始数据快照
+ * - 对 reactive 对象：通过隐藏的 `__signal__` 获取当前值（不收集依赖）
+ * - 对 ref：返回其 `.value`
+ * - 其他：原样返回
+ */
+export function toRaw<T = any>(obj: any): T;
+
+
+
+/**
+ * 创建 Ref：返回一个带有 `value` 字段的响应式代理对象
+ *
+ * 用法（JavaScript / TypeScript）：
+ * ```ts
+ * // 基本使用：读写 value，自动依赖收集
+ * const r = ref(0)
+ * console.log(r.value)        // 0
+ * r.value = 1                 // 触发订阅者
+ *
+ * // 与 watchEffect 配合（依赖自动收集）
+ * const stop = watchEffect(() => {
+ *   console.log('ref value =', r.value)
+ * })
+ * r.value = 2                 // 触发前面的 watchEffect
+ * stop()                      // 停止响应
+ *
+ * // peek：查看当前值，不收集依赖（不会订阅当前副作用）
+ * const cur = r.peek()        // 仅返回值，不产生订阅
+ *
+ * // update：基于当前值计算并写回
+ * r.update(prev => prev + 1)  // 等价于 r.value = (prev + 1)
+ *
+ * // 自定义等值比较：避免无意义的触发
+ * const r2 = ref({ a: 1 }, { equals: (p, n) => _.isEqual(p?.value, n?.value) })
+ * r2.value = { a: 1 }         // 不触发（相等）
+ *
+ * // 与组件/DOM 结合（Vapor 模式下自动更新）
+ * // <span>{r.value}</span> 会被编译为原生 DOM + 响应式更新
+ * ```
+ */
+export function ref<T = any>(
+  initial: T,
+  options?: { equals?: Equals<T> } | null,
+  forceGlobal?: boolean,
+): { value: T };
+
+
+
+/**
+ * useRef：在 Hook 插槽上持久化 { current } 容器
+ */
+export function useRef<T = any>(initial?: T): { current: T | undefined };
+
+
+
+/**
+ * 创建计算属性
+ * - 参数：可为函数 `() => any`，或对象 `{ get: () => any }`
+ * 返回：一个只读信号句柄（通过 get/peek 读取，内部通过 effect 驱动更新）
+ * 示例（JavaScript）：
+ * ```javascript
+ * const count = signal(1);
+ * const double = computed(() => count.get() * 2);
+ *
+ * createEffect(() => {
+ *   console.log('double =', double.get());
+ * });
+ *
+ * count.set(2); // double 将变为 4 并触发订阅者
+ * ```
+ * 更多用法示例：
+ *
+ * 1) 对象参数（只读 getter）：
+ * ```javascript
+ * const first = signal('John');
+ * const last = signal('Doe');
+ * const fullName = computed({
+ *   get: () => first.get() + ' ' + last.get()
+ * });
+ * createEffect(() => {
+ *   console.log('fullName =', fullName.get()); // John Doe
+ * });
+ * ```
+ *
+ * 2) 通过更新源信号实现“可写效果”（模拟 Vue3 的 setter 行为）：
+ * ```javascript
+ * const setFullName = (nv) => {
+ *   const [f, l] = nv.split(' ');
+ *   first.set(f);
+ *   last.set(l);
+ * };
+ * setFullName('David Smith'); // fullName 将变为 "David Smith"
+ * ```
+ *
+ * 3) 直接使用 `{ get, set }` 创建“可写 computed”，支持 `.set(value)`：
+ * ```javascript
+ * const fullName = computed({
+ *   get: () => first.get() + ' ' + last.get(),
+ *   set: (nv) => {
+ *     const [f, l] = nv.split(' ');
+ *     first.set(f);
+ *     last.set(l);
+ *   }
+ * });
+ * fullName.set('David Smith'); // 将调用你的 set 更新源信号，并重算派生值
+ * ```
+ */
+export function computed<T>(get: ComputedGetter<T>, forceGlobal?: boolean): ReadonlySignal<T>
+export function computed<T>(options: ComputedOptions<T>, forceGlobal?: boolean): WritableSignal<T>
+export function computed<T>(
+  arg: any,
+  forceGlobal?: boolean,
+): ReadonlySignal<T> | WritableSignal<T>;
+
+
+
+/**
+ * 创建 Reactive：返回一个对象/数组的响应式代理（深/浅、只读可选）
+ *
+ * 用法（JavaScript / TypeScript）：
+ * ```ts
+ * // 基础对象：读取与写入都响应式
+ * const state = reactive({ user: { name: 'A' }, items: ['x'] })
+ * console.log(state.user.name)     // 'A'
+ * state.user.name = 'B'            // 写入嵌套字段，触发订阅者
+ * state.items.push('y')            // 数组写入也可触发（通过路径写入实现不可变更新）
+ *
+ * // 在 Vapor JSX 中使用（自动 DOM 更新）
+ * // <span>{state.user.name}</span>
+ * // <input value={state.user.name} onInput={e => state.user.name = e.target.value} />
+ *
+ * // 只读代理：禁止写入
+ * const ro = reactive({ a: 1 }, { readonly: true })
+ * // ro.a = 2 // 将被忽略或导致失败（只读）
+ *
+ * // 浅代理：仅对顶层对象进行代理，子对象不递归代理
+ * const sh = reactive({ nested: { a: 1 } }, { shallow: true })
+ * // sh.nested 仍为普通对象（非代理）
+ *
+ * // 原始类型：普通值会自动包裹为 { value } 并返回其代理
+ * const num = reactive(0)
+ * console.log(num.value)       // 0
+ * num.value = 1               // 写入 value 字段触发订阅者
+ * const str = reactive('A')
+ * str.value = 'B'             // 原始类型统一通过 value 字段读写
+ *
+ * // 自定义等值比较：用于控制触发频率
+ * const eq = (prev: any, next: any) => _.isEqual(prev, next)
+ * const obj = reactive({ a: 1 }, { equals: eq })
+ * obj.a = 1 // 不触发（相等）
+ * ```
+ */
+export function reactive<T extends Primitive>(
+  initial: T,
+  options?: ReactiveOptions<T>,
+  forceGlobal?: boolean,
+): { value: Widen<T> }
+export function reactive<T extends object | Function>(
+  initial: T,
+  options?: ReactiveOptions<T>,
+  forceGlobal?: boolean,
+): T
+export function reactive<T = any>(
+  initial: T,
+  options?: ReactiveOptions<T>,
+  forceGlobal?: boolean,
+): any
+
+/**
+ * 创建 Reactive：返回一个对象/数组的响应式代理（浅）
+ *
+ * 用法（JavaScript / TypeScript）：
+ * ```ts
+ * // 只读代理：禁止写入
+ * const ro = shallowReactive({ a: 1 })
+ * // ro.a = 2 // 将被忽略或导致失败（只读）
+ *
+ * // 浅代理：仅对顶层对象进行代理，子对象不递归代理
+ * const sh = shallowReactive({ nested: { a: 1 } })
+ * // sh.nested 仍为普通对象（非代理）
+ *
+ * // 自定义等值比较：用于控制触发频率
+ * const eq = (prev: any, next: any) => _.isEqual(prev, next)
+ * const obj = shallowReactive({ a: 1 }, { equals: eq })
+ * obj.a = 1 // 不触发（相等）
+ * ```
+ */
+export function shallowReactive<T extends object>(
+  initial: T,
+  options?: { equals?: Equals<T> },
+  forceGlobal?: boolean,
+): T
+
+/**
+ * 创建 Reactive：返回一个对象/数组的响应式代理（深度只读）
+ *
+ * 用法（JavaScript / TypeScript）：
+ * ```ts
+ * // 只读代理：禁止写入
+ * const ro = readonly({ a: 1 })
+ * // ro.a = 2 // 将被忽略或导致失败（只读）
+ * ```
+ */
+export function readonly<T extends object>(initial: T, forceGlobal?: boolean): T
+
+/**
+ * 创建 Reactive：返回一个对象/数组的响应式代理（第一层只读）
+ *
+ * 用法（JavaScript / TypeScript）：
+ * ```ts
+ * // 只读代理：禁止写入
+ * const ro = readonly({ a: 1, b: {hello: 'world'} })
+ * // ro.a = 2 // 将被忽略或导致失败（只读）
+ * // ro.hello = 'new world' // 成功
+ * ```
+ */
+export function shallowReadonly<T extends object>(initial: T, forceGlobal?: boolean): T
+
+
+
+/**
+ * useMemo：根据依赖数组缓存计算结果，等值依赖不重新计算
+ */
+export function useMemo<T>(factory: () => T, deps: any[]): T;
+
+
+
+/**
+ * useSetup：仅在首次调用时计算一次并缓存
+ */
+export function useSetup<T>(factory: () => T): T;
+
+
+
+/**
+ * useState 选项
+ */
+export interface UseStateOptions<T = any> {
+  equals?: (prev: T, next: T) => boolean
+  kind?: 'reactive' | 'ref' | 'signal'
+}
+
+/**
+ * useState 钩子：统一的轻量状态容器（支持 reactive/ref/signal 三种形态）
+ *
+ * 设计概览：
+ * - 默认形态为 `reactive`：当初始值为对象/数组时直接返回其响应式代理；当为原始类型时自动包裹为 `{ value }` 并返回其代理。
+ * - 可选 `kind`：
+ *   - `'reactive'`：对象/数组的响应式代理；原始类型将自动包裹为 `{ value }`
+ *   - `'ref'`：总是返回 `{ value }` 的响应式代理，便于统一读写
+ *   - `'signal'`：返回底层 `SignalHandle`，适合需要精细控制 get/set/update/path 的场景
+ * - 等值比较：通过 `options.equals(prev, next)` 自定义比较逻辑，返回 `true` 表示值相等，不触发订阅者。
+ *
+ * 使用示例（JavaScript / TypeScript）：
+ * // reactive（默认）
+ * const [state, setState] = useState({ user: { name: 'A' }, items: ['x'] })
+ * state.user.name = 'B'        // 响应式写入
+ * setState({ user: { name: 'C' }, items: ['y'] })  // 整体替换
+ * setState(prev => ({ ...prev, user: { ...prev.user, name: 'D' } })) // 基于回调更新
+ *
+ * // ref（原始类型亦可统一为 { value }）
+ * const [count, setCount] = useState(0, { kind: 'ref' })
+ * console.log(count.value)     // 0
+ * setCount(1)                  // 触发订阅者
+ * setCount(ref => { ref.value += 1 }) // 2
+ *
+ * // signal（底层句柄）
+ * const [sig, setSig] = useState({ a: 1 }, { kind: 'signal' })
+ * console.log(sig.get())       // { a: 1 }
+ * sig.set({ a: 2 })            // 触发订阅者
+ * setSig(handle => ({ a: handle.peek().a + 1 })) // { a: 3 }
+ * sig.setPath('a', 4)          // 路径写入
+ * console.log(sig.get())       // { a: 4 }
+ *
+ * // 自定义等值比较（默认使用 shallowEqual）
+ * const [state2, setState2] = useState({ a: 1, b: 2 }, { kind: 'reactive', equals: (prev, next) => prev.a === next.a })
+ * setState2({ a: 1, b: 3 })   // 不触发订阅者，因为 a 未改变
+ * setState2({ a: 2, b: 4 })   // 触发订阅者，因为 a 改变
+ */
+export function useState<T extends Primitive>(
+  initial: T | (() => T),
+  options?: UseStateOptions<T> & { kind?: 'reactive' | 'ref' },
+): [{ value: Widen<T> }, (v: Widen<T> | ((ref: { value: Widen<T> }) => Widen<T> | void)) => void]
+export function useState<T extends Primitive>(
+  initial: T | (() => T),
+  options: UseStateOptions<T> & { kind: 'signal' },
+): [SignalHandle<Widen<T>>, (v: Widen<T> | ((sig: SignalHandle<Widen<T>>) => Widen<T> | void)) => void]
+export function useState<T extends object | Function>(
+  initial: T | (() => T),
+  options: UseStateOptions<T> & { kind: 'reactive' },
+): [T, (v: T | ((state: T) => T | void)) => void]
+export function useState<T extends object | Function>(
+  initial: T | (() => T),
+  options?: UseStateOptions<T> & { kind?: 'reactive' },
+): [T, (v: T | ((state: T) => T | void)) => void]
+export function useState<T extends object | Function>(
+  initial: T | (() => T),
+  options: UseStateOptions<T> & { kind: 'ref' },
+): [{ value: T }, (v: T | ((ref: { value: T }) => T | void)) => void]
+export function useState<T extends object | Function>(
+  initial: T | (() => T),
+  options: UseStateOptions<T> & { kind: 'signal' },
+): [SignalHandle<T>, (v: T | ((sig: SignalHandle<T>) => T | void)) => void]
+
+
+
+/**
+ * 设置调度模式
+ * - mode="sync"：信号变更时尽可能同步触发副作用
+ * - 其他值：采用默认微任务合并调度
+ * 示例（JavaScript）：
+ * ```javascript
+ * const { setReactiveScheduling } = wasmModule;
+ * setReactiveScheduling('sync'); // 适合少量、快速的更新
+ * // setReactiveScheduling('microtask'); // 使用默认微任务合并（传非 "sync" 即可）
+ * ```
+ */
+export function setReactiveScheduling(mode: 'sync' | string): void;
+
+/**
+ * 通用取值转换
+ * 支持以下输入：
+ * - 函数：调用并返回其结果
+ * - 对象：优先读取 `value` 字段，其次尝试调用 `get()` 方法
+ * - 其他：直接返回原值
+ * 示例（JavaScript）：
+ * ```javascript
+ * const { toValue } = wasmModule;
+ * toValue(() => 1); // 1
+ * toValue({ value: 2 }); // 2
+ * toValue({ get() { return 3; } }); // 3
+ * toValue('hello'); // 'hello'
+ * ```
+ */
+export function toValue<T>(x: T | (() => T) | { value?: T; get?: () => T }): T;
+
+/**
+ * 原始类型：普通值会自动包裹为 { value } 并返回其代理
+ */
+type Primitive = string | number | bigint | boolean | symbol | null | undefined
+
+/**
+ * 扩展原始类型：将原始值包裹为 { value: T } 并返回其代理
+ */
+type Widen<T> = T extends string
+  ? string
+  : T extends number
+    ? number
+    : T extends boolean
+      ? boolean
+      : T extends bigint
+        ? bigint
+        : T extends symbol
+          ? symbol
+          : T extends null | undefined
+            ? T
+            : never
+
+
+
+/**
+ * 侦听选项：{ immediate?: bool, scheduler?: Function, equals?: Function, debounce?: number }
+ */
+export interface WatchOptions<T = any> {
+  immediate?: boolean;
+  scheduler?: (run: () => void) => void;
+  equals?: (prev: T, next: T) => boolean;
+  debounce?: number;
+}
+
+/**
+ * 侦听副作用：在副作用体内自行读取信号，依赖会自动收集
+ * 类似 Vue 的 `watchEffect`
+ * 示例（JavaScript）：
+ * ```javascript
+ * const { createSignal, watchEffect } = wasmModule;
+ * const s = createSignal(0);
+ * watchEffect(() => {
+ *   console.log('value:', s.get());
+ * }, {
+ *     //可选 scheduler
+ * });
+ * s.set(1);
+ * ```
+ */
+export function watchEffect(
+  cb: () => void,
+  options?: { scheduler?: (run: () => void) => void } | null,
+): EffectHandle;
+
+/** 
+ * 侦听任意 getter 函数的结果变化
+ * options: { immediate?: bool, scheduler?: Function, equals?: Function }
+ * 示例（JavaScript）：
+ * ```javascript
+ * const { watchFn } = wasmModule;
+ * const obj = { value: 0 };
+ * const stop = watchFn(
+ *   () => obj.value,
+ *   (newv, oldv) => console.log('changed:', oldv, '->', newv),
+ *   { immediate: true }
+ * );
+ * obj.value = 1; // 当 getter 读取到新值时触发 handler
+ * ```
+ */
+export function watchFn<T>(
+  getter: () => T,
+  handler: (newv: T, oldv: T) => void,
+  options?: WatchOptions<T> | null,
+): EffectHandle;
+
+/** 
+ * 侦听信号值变化：`src` 为信号句柄，`handler` 为值变化时的回调函数
+ * options: { immediate?: bool, scheduler?: Function, equals?: Function }
+ * 示例（JavaScript）：
+ * ```javascript
+ * const { createSignal, watchSignal } = wasmModule;
+ * const s = createSignal(0);
+ * watchSignal(s, (newv, oldv) => {
+ *   console.log('value:', oldv, '->', newv);
+ * }, { immediate: true });
+ * s.set(1); // 当信号值变化时触发 handler
+ * ```
+ */
+export function watchSignal(
+  src: SignalHandle,
+  handler: (newv: any, oldv: any) => void,
+  options?: WatchOptions<any> | null,
+): EffectHandle;
+
+/** 
+ * 侦听信号值变化（深度）：`src` 为信号句柄，`handler` 为值变化时的回调函数
+ * options: { immediate?: bool, scheduler?: Function, equals?: Function }
+ * 示例（JavaScript）：
+ * ```javascript
+ * const { createSignal, watchDeepSignal } = wasmModule;
+ * const s = createSignal({ a: 0 });
+ * watchDeepSignal(s, (newv, oldv) => {
+ *   console.log('value:', oldv, '->', newv);
+ * }, { immediate: true });
+ * s.set({ a: 1 }); // 当信号值变化时触发 handler
+ * ```
+ */
+export function watchDeepSignal(
+  src: SignalHandle,
+  handler: (newv: any, oldv: any) => void,
+  options?: WatchOptions<any> | null,
+): EffectHandle;
+
+/** 
+ * 侦听信号路径值变化：`src` 为信号句柄，`path` 为路径（数组或点分字符串），`handler` 为值变化时的回调函数
+ * options: { immediate?: bool, scheduler?: Function, equals?: Function }
+ * 示例（JavaScript）：
+ * ```javascript
+ * const { createSignal, watchPath } = wasmModule;
+ * const s = createSignal({ a: { b: 0 } });
+ * watchPath(s, ['a','b'], (n, o) => {
+ *   console.log('b changed:', o, '->', n)
+ * }, { immediate: true })
+ * s.setPath(['a','b'], 1) // 当路径值变化时触发 handler
+ * ```
+ */
+export function watchPath(
+  src: SignalHandle,
+  path: string | Array<string | number>,
+  handler: (newv: any, oldv: any) => void,
+  options?: WatchOptions<any> | null,
+): EffectHandle;
+
+/**
+ * 侦听来源：信号句柄、getter 函数或来源数组（信号句柄 / getter 函数）
+ */
+export type WatchSource<T = any> = SignalHandle | (() => T) | Array<SignalHandle | (() => any)>;
+
+/**
+ * 侦听任意来源变化：`source` 为信号句柄、getter 函数或来源数组（信号句柄 / getter 函数 / 常量），`handler` 为变化时的回调函数
+ * options: { immediate?: bool, scheduler?: Function, equals?: Function }
+ * 示例（JavaScript）：
+ * ```javascript
+ * const { createSignal, watch } = wasmModule;
+ * const s1 = createSignal(0);
+ * const s2 = createSignal(10);
+ * watch([s1, s2, 'x'], (n, o) => {
+ *   console.log('values:', o, '->', n);
+ * }, { immediate: true });
+ * s1.set(1); s2.set(11); // 当来源数组中任意值变化时触发 handler
+ * ```
+ */
+export function watch<T>(
+  source: WatchSource<T>,
+  handler: (newv: T | any[], oldv: T | any[]) => void,
+  options?: WatchOptions<T | any[]> | null,
+): EffectHandle;
+
+
+
+/**
+ * 副作用句柄：用于在 JS 侧停止副作用
+ */
+export interface EffectHandle {
+  /** 停止后续运行，并执行最后一次已注册的清理 */
+  dispose(): void;
+}
+
+/**
+ * 创建副作用（立即运行一次），并返回句柄
+ * 示例（JavaScript）：
+ * ```javascript
+ * const { createSignal, createEffect, onCleanup, untrack, batch } = wasmModule;
+ * const s = createSignal(0);
+ *
+ * // 基本副作用：读取信号并打印
+ * createEffect(() => {
+ *   console.log('value:', s.get());
+ * });
+ * s.set(1);
+ *
+ * // 清理示例：注册定时器并在下一次运行前清理
+ * createEffect(() => {
+ *   const id = setInterval(() => console.log('tick'), 1000);
+ *   onCleanup(() => clearInterval(id));
+ * });
+ *
+ * // 断开依赖收集：不会订阅 other 信号
+ * createEffect(() => {
+ *   const v = untrack(() => s.get());
+ *   console.log('untracked:', v);
+ * });
+ *
+ * 创建副作用（支持自定义调度器与懒执行）
+ * options:
+ * - scheduler: Function( run: Function )，用于自定义何时调用 run
+ * - lazy: bool，true 时不在创建时立即运行
+ * 示例（JavaScript）：
+ * ```javascript
+ * const { createEffect } = wasmModule;
+ * const scheduler = (run) => queueMicrotask(run); // 或者使用 requestAnimationFrame
+ * createEffect(() => {
+ *   // ...effect body
+ * }, { scheduler, lazy: false });
+ * ```
+ */
+export function createEffect(
+  cb: () => void,
+  options?: { scheduler?: (run: () => void) => void; lazy?: boolean } | null,
+): EffectHandle;
+
+/**
+ * 在当前运行的副作用上注册清理函数
+ * 清理函数会在下一次该副作用执行之前被调用
+ * 用法与示例（JavaScript）：
+ * ```js
+ * // 需求：每次依赖变化时重建一个定时器，并在下一次运行前清理上一次的定时器
+ * const s = createSignal(0)
+ * const eh = createEffect(() => {
+ *   const v = s.get() // 建立订阅
+ *   const id = setInterval(() => console.log('[onCleanup-demo] tick v=', v), 500)
+ *   onCleanup(() => clearInterval(id)) // 下次运行前清理上一次的定时器
+ * })
+ * s.set(1) // 触发重跑：先清理旧定时器，再创建新定时器（只保留一个）
+ * s.set(2) // 同理
+ * eh.dispose() // 停止后续运行，并执行最后一次已注册的清理（定时器不再 tick）
+ * ```
+ */
+export function onCleanup(cb: () => void): void;
+
+/**
+ * 断开依赖收集地执行回调（不记录对 Signal 的订阅）
+ *
+ * 用途与示例（JavaScript）：
+ * - 在同一个副作用中，订阅主依赖 `a`，但临时读取 `b` 并且不希望 `b` 的变化触发该副作用。
+ * - `untrack(fn)` 会在执行 `fn` 时临时关闭依赖收集，`fn` 内部对信号的读取不会把当前副作用订阅到这些信号上。
+ *
+ * ```js
+ * const a = createSignal(0)
+ * const b = createSignal(0)
+ * createEffect(() => {
+ *   const av = a.get()                // 订阅 a：a 变化会使该副作用重跑
+ *   const bv = untrack(() => b.get()) // 断开依赖读取 b：b 变化不会触发该副作用
+ *   console.log('[untrack-demo] run av=', av, 'bv=', bv)
+ * })
+ * b.set(1)  // 不触发副作用（因为对 b 的读取发生在 untrack 内）
+ * b.set(2)  // 不触发副作用
+ * a.set(10) // 触发副作用（因为对 a 进行了正常订阅）
+ * ```
+ *
+ * 说明：若仅需“不订阅地读取”某个信号，也可使用 `peek()`（例如 `const v = sig.peek()`）。
+ */
+export function untrack<T>(cb: () => T): T;
+
+/**
+ * 批量更新：在回调期间抑制副作用的即时触发，统一在结束后刷新
+ *
+ * 用法与示例（JavaScript）：
+ * ```js
+ * const { createSignal, createEffect, batch } = wasmModule
+ *
+ * // 示例一：同一信号多次 set，仅在批量结束后重跑一次
+ * const count = createSignal(0)
+ * createEffect(() => {
+ *   console.log('[batch-demo] count =', count.get())
+ * })
+ * batch(() => {
+ *   count.set(1)
+ *   count.set(2)
+ *   count.set(3)
+ *   // 在批量范围内不会立即触发副作用
+ * })
+ * // 批量结束后只触发一次副作用，打印最新值 3
+ *
+ * // 示例二：一次性更新多个信号，副作用只合并重跑一次
+ * const a = createSignal(0)
+ * const b = createSignal(0)
+ * createEffect(() => {
+ *   console.log('[batch-demo] sum =', a.get() + b.get())
+ * })
+ *  batch(() => {
+ *    a.set(10)
+ *    b.set(20)
+ *  }) // 仅一次重跑，输出 sum = 30
+ * ``` 
+ */
+export function batch(cb: () => void): void;
+
+
+
+/**
+ * 自定义等值比较函数类型：`(prev: T, next: T) => boolean`
+ */
+export type Equals<T> = (prev: T, next: T) => boolean;
+
+/**
+ * 响应式选项：用于创建响应式对象/数组
+ */
+export interface ReactiveOptions<T> {
+  equals?: Equals<T>
+  readonly?: boolean
+  shallow?: boolean
+}
+
+/**
+ * 信号句柄：包含
+ * `{ get, peek, set, update, getPath, setPath, updatePath, peekPath, toJSON, valueOf, toString, value }` 方法/属性
+ */
+export interface SignalHandle<T> {
+  /**
+   * 读取当前值，并在有正在运行的副作用时将其订阅到该信号
+   */
+  get(): T
+
+  /**
+   * 查看当前值：不进行依赖收集（不订阅当前副作用）
+   */
+  peek(): T
+
+  /**
+   * 查看路径值：不进行依赖收集（不订阅当前副作用）
+   *
+   * 用法（JavaScript）：
+   * ```js
+   * const s = signal({ user: { name: 'A' }, items: ['x'] })
+   * const n = s.peekPath('user.name')   // 'A'（不订阅）
+   *
+   * // 边界：
+   * // - 空路径：返回根值（不订阅）
+   * console.log(s.peekPath([]))     // { user: { name: 'A' }, items: ['x'] }
+   * console.log(s.peekPath(''))     // { user: { name: 'A' }, items: ['x'] }
+   * ```
+   */
+  peekPath(path: string | Array<string | number>): any
+
+  /**
+   * 设置新值，按等值比较决定是否通知订阅者
+   */
+  set(value: T): void
+
+  /**
+   * 根据回调对当前值进行计算并设置（相当于 set( updater(current) )）
+   */
+  update(updater: (current: T) => T): void
+
+  /**
+   * JSON 序列化：`JSON.stringify(signal)` 时返回内部值
+   */
+  toJSON(): T
+
+  /**
+   * 原始值表示：`signal.valueOf()` 返回内部值
+   */
+  valueOf(): T
+
+  /**
+   * 字符串表示：`String(signal)` 返回 JSON 字符串或占位文本
+   */
+  toString(): string
+
+  /**
+   * 只读/写属性：`signal.value` 直接读取内部值；写入等价于 `set`
+   *
+   * 用法（JavaScript）：
+   * ```js
+   * const s = signal(0)
+   * console.log(s.value) // 0（不订阅）
+   * s.value = 1          // 等价于 s.set(1)
+   * ```
+   */
+  value: T
+
+  /**
+   * 根据路径读取当前对象/数组的子项值（依赖收集）
+   *
+   * 用法（JavaScript）：
+   * ```js
+   * const s = signal({ user: { profile: { name: 'A' } }, items: ['x'] })
+   * const name1 = s.getPath(['user','profile','name']) // 'A'
+   * const name2 = s.getPath('user.profile.name') // 'A'
+   * // 在 watch 中使用路径读取会自动依赖收集
+   * watchFn(() => s.getPath(['user','profile','name']), (n, o) => {  })
+   * watchFn(() => s.getPath('user.profile.name'), (n, o) => {  })
+   *
+   * // 边界：
+   * // - 空路径：返回根值并订阅
+   * const root = s.getPath([]) // 订阅根
+   * // - 数字字段解析：'items.0' 解析为 ['items', 0]
+   * const first = s.getPath('items.0') // 'x'
+   * ```
+   */
+  getPath(path: string | Array<string | number>): any
+
+  /**
+   * 根据路径设置对象/数组的子项值：不可变更新，生成新的根对象并触发订阅者
+   *
+   * 用法（JavaScript）：
+   * ```js
+   * const s = signal({ user: { profile: { name: 'A' }, age: 20 }, items: ['x'] })
+   * // 设置嵌套对象字段（数组路径）
+   * s.setPath(['user', 'profile', 'name'], 'B')
+   * // 设置数组元素（数组路径）
+   * s.setPath(['items', 0], 'y')
+   * // 字符串路径（以 . 分隔，数字段转为数组索引）
+   * s.setPath('user.profile.name', 'B')
+   * s.setPath('items.0', 'y')
+   * // 若根不是对象/数组，会以空对象作为根进行赋值
+   * s.setPath(['foo', 'bar'], 1)
+   * s.setPath('foo.bar', 1)
+   *
+   * // 边界：
+   * // - 空路径：替换整个根值并触发订阅者
+   * s.setPath([], { user: { profile: { name: 'C' } } })
+   * s.setPath('', { user: { profile: { name: 'D' } } })
+   * // - 缺失中间段：自动以空对象占位
+   * s.setPath(['config','theme','color'], 'red') // 若 'config' 不存在，将创建为 {}
+   * // - 数组越界写入：当目标段为现有数组时会扩展长度
+   * s.setPath(['items', 2], 'z') // items: ['x', undefined, 'z']
+   * // - 函数值不执行：作为普通值读写
+   * const fn = () => 42
+   * s.setPath('cb', fn)
+   * console.log(typeof s.getPath('cb')) // 'function'
+   * ```
+   *
+   * 参数：
+   * - `path`: JS 数组或以 `.` 分隔的字符串（如 `['user','profile','name']`、`['items', 0]` 或 `'user.profile.name'`、`'items.0'`）
+   * - `value`: 目标路径的新值
+   * 行为与边界：
+   * - 路径缺失会自动以空对象占位，数组越界写入会扩展长度
+   * - 根为非对象/数组时以空对象为根进行赋值
+   * - 函数值作为普通值读写，不会被执行
+   */
+  setPath(path: string | Array<string | number>, value: any): void
+
+  /**
+   * 根据路径函数式更新子项：`updater(currentAtPath) -> nextAtPath`
+   *
+   * 用法（JavaScript）：
+   * ```js
+   * const s = signal({ user: { age: 20 }, items: ['x'] })
+   * s.updatePath(['user','age'], prev => prev + 1) // age: 21
+   * s.updatePath(['user','name'], prev => (prev || '').toUpperCase())
+   * // 使用字符串路径
+   * s.updatePath('user.age', prev => prev + 1) // age: 21
+   * s.updatePath('items.0', prev => (prev || '').toUpperCase())
+   *
+   * // 边界：
+   * // - 空路径：以根值为输入进行整体更新
+   * s.updatePath([], root => ({ ...root, flag: true }))
+   * s.updatePath('', root => ({ ...root, mark: 1 }))
+   * // - 缺失段：以空对象占位后再写入
+   * s.updatePath(['config','theme'], prev => ({ ...(prev || {}), mode: 'dark' }))
+   * ```
+   */
+  updatePath(
+    path: string | Array<string | number>,
+    updater: (currentAtPath: any) => any,
+  ): void
+}
+
+/**
+ * 创建信号：`createSignal(initialValue, { equals?: Equals<T> })`
+ *
+ * 参数：
+ * - `initialValue`: 初始值
+ * - `options.equals`: 自定义等值比较函数，默认使用 `===`
+ *
+ * 示例（JavaScript）：
+ * ```javascript
+ * const s = createSignal(0)
+ * s.set(1) // 通知订阅者
+ * s.set(1) // 不通知订阅者（因为 === 相等）
+ *
+ * const s2 = createSignal({ a: 0 }, { equals: (prev, next) => JSON.stringify(prev) === JSON.stringify(next) })
+ * s2.set({ a: 0 }) // 通知订阅者
+ * s2.set({ a: 0 }) // 不通知订阅者（因为 JSON.stringify 相等）
+ * ```
+ */
+export function createSignal<T = any>(
+  initial: T,
+  options?: { equals?: Equals<T> },
+): SignalHandle<T>;
+
+/**
+ * 创建引用信号：`createRef(initialValue)`
+ *
+ * 参数：
+ * - `initialValue`: 初始值
+ *
+ * 示例（JavaScript）：
+ * ```javascript
+ * const ref = createRef(0)
+ * ref.set(1) // 通知订阅者
+ * ref.set(1) // 不通知订阅者（因为 === 相等）
+ *
+  * // 属性与调试方法
+  * console.log(ref.value)           // 0（不订阅）
+  * ref.value = 2                    // 等价于 ref.set(2)
+  * console.log(String(ref))         // 调用 toString()
+  * console.log(ref.valueOf())       // 调用 valueOf()
+  * console.log(JSON.stringify(ref)) // 调用 toJSON()
+ * ```
+ */
+export function createRef<T = any>(initial: T): SignalHandle<T>;
+
+/**
+ * 创建 Reactive：返回一个对象/数组的响应式代理（深/浅、只读可选）
+ *
+ * 用法（JavaScript / TypeScript）：
+ * ```ts
+ * // 基础对象：读取与写入都响应式
+ * const state = createReactive({ user: { name: 'A' }, items: ['x'] })
+ * console.log(state.user.name)     // 'A'
+ * state.user.name = 'B'            // 写入嵌套字段，触发订阅者
+ * state.items.push('y')            // 数组写入也可触发（通过路径写入实现不可变更新）
+ *
+ * // 在 Vapor JSX 中使用（自动 DOM 更新）
+ * // <span>{state.user.name}</span>
+ * // <input value={state.user.name} onInput={e => state.user.name = e.target.value} />
+ *
+ * // 只读代理：禁止写入
+ * const ro = createReactive({ a: 1 }, { readonly: true })
+ * // ro.a = 2 // 将被忽略或导致失败（只读）
+ *
+ * // 浅代理：仅对顶层对象进行代理，子对象不递归代理
+ * const sh = createReactive({ nested: { a: 1 } }, { shallow: true })
+ * // sh.nested 仍为普通对象（非代理）
+ *
+ * // 原始类型：普通值会自动包裹为 { value } 并返回其代理
+ * const num = createReactive(0)
+ * console.log(num.value)       // 0
+ * num.value = 1               // 写入 value 字段触发订阅者
+ * const str = createReactive('A')
+ * str.value = 'B'             // 原始类型统一通过 value 字段读写
+ *
+ * // 自定义等值比较：用于控制触发频率
+ * const eq = (prev: any, next: any) => _.isEqual(prev, next)
+ * const obj = createReactive({ a: 1 }, { equals: eq })
+ * obj.a = 1 // 不触发（相等）
+ * ```
+ */
+export function createReactive<T = any>(
+  initial: T,
+  options?: ReactiveOptions<T>,
+): never;
+export function createReactive<T extends Primitive>(
+  initial: T,
+  options?: ReactiveOptions<T>,
+): { value: Widen<T> };
+export function createReactive<T extends object | Function>(
+  initial: T,
+  options?: ReactiveOptions<T>,
+): T;
+
+
+
+/**
+ * 组件实例上下文，用于响应式访问 Hook 插槽
+ */
+export interface HookContainer {
+  states: any[];
+  index: number;
+  __forcedIndex?: number;
+  [key: string]: any;
+}
+
+/**
+ * 组件实例上下文类型，可用于类型注解
+ */
+export type HookHost =
+  | (Record<string, any> & { __hooks?: HookContainer })
+  | null
+  | undefined;
+
+/**
+ * 设置当前实例
+ * 传入 `null/undefined` 表示清空；否则记录为 Some(instance)
+ * 示例（JavaScript）：
+ * ```javascript
+ * const { setCurrentInstance, getCurrentInstance, withHookSlot, createSignal } = wasmModule;
+ * const inst = { name: 'MyComponent' };
+ * setCurrentInstance(inst);
+ *
+ * // 在实例上分配一个 Hook 插槽，用于存储状态对象
+ * const state = withHookSlot(() => ({ count: createSignal(0) }));
+ * console.log(getCurrentInstance()); // 当前实例或根实例
+ * ```
+ */
+export function setCurrentInstance(instance: HookHost): void;
+
+/**
+ * 获取当前实例；若未设置则返回空值（null/undefined），不再构造默认根实例
+ * 用法（JavaScript）：
+ * ```javascript
+ * const { setCurrentInstance, getCurrentInstance, withHookSlot } = wasmModule;
+ *
+ * // 设置并获取当前实例
+ * setCurrentInstance({ name: 'A' });
+ * const inst = getCurrentInstance(); // { name: 'A', ... }
+ *
+ * // 清空当前实例后，获取为空（undefined 或 null）
+ * setCurrentInstance(undefined);
+ * const none = getCurrentInstance(); // undefined（或 null）
+ *
+ * // 在有当前实例时，withHookSlot 为该实例分配/复用一个 Hook 插槽
+ * setCurrentInstance({});
+ * const state = withHookSlot(() => ({ count: 0 })); // 首次创建并缓存到 __hooks.states
+ * ```
+ */
+export function getCurrentInstance(): HookHost;
+
+/**
+ * 在当前实例上为 Hook 分配/复用一个插槽
+ * - 若无当前实例，则直接执行 factory 返回对象
+ * - 有实例时，依据 `__hooks.index` 或 `__forcedIndex` 计算插槽序号
+ * 示例（JavaScript）：
+ * ```javascript
+ * const { setCurrentInstance, withHookSlot } = wasmModule;
+ * setCurrentInstance({});
+ * const a = withHookSlot(() => ({ id: 1 }));
+ * const b = withHookSlot(() => ({ id: 2 }));
+ * // 若再次调用 withHookSlot（且未强制索引），将分配下一个插槽
+ * ```
+ */
+export function withHookSlot<T = any>(factory: () => T): T;
+
+/**
+ * 通过唯一 id 为 Hook 分配稳定插槽索引并运行回调
+ * - 若该 id 尚未存在，则以当前 `states.length` 作为新索引
+ * - 运行期间通过设置 `__forcedIndex` 确保 `withHookSlot` 使用该索引
+ * - 运行结束后自动清理 `__forcedIndex`
+ */
+export function vaporWithHookId<T = any>(id: string, runner: () => T): T;
+
+
+
+/**
+ * 只读信号句柄：仅提供 get/peek 方法，不支持 set/update
+ */
+export interface ReadonlySignal<T> { get(): T; peek(): T }
+
+/**
+ * 可写信号句柄：提供 get/peek/set/update 方法
+ */
+export interface WritableSignal<T> extends ReadonlySignal<T> {
+  set(value: T): void;
+  update?(updater: (current: T) => T): void;
+}
+
+/**
+ * 计算属性 getter 函数类型：`() => any`
+ */
+export type ComputedGetter<T> = () => T;
+
+/**
+ * 计算属性 setter 函数类型：`(value: T) => void`
+ */
+export type ComputedSetter<T> = (value: T) => void;
+
+/**
+ * 计算属性选项：{ get: ComputedGetter<T>, set?: ComputedSetter<T> }
+ */
+export interface ComputedOptions<T> { get: ComputedGetter<T>; set?: ComputedSetter<T> }
+
+/**
+ * 创建计算属性
+ * - 参数：可为函数 `() => any`，或对象 `{ get: () => any }`
+ * 返回：一个只读信号句柄（通过 get/peek 读取，内部通过 effect 驱动更新）
+ * 示例（JavaScript）：
+ * ```javascript
+ * const { createSignal, createComputed, createEffect } = wasmModule;
+ * const count = createSignal(1);
+ * const double = createComputed(() => count.get() * 2);
+ *
+ * createEffect(() => {
+ *   console.log('double =', double.get());
+ * });
+ *
+ * count.set(2); // double 将变为 4 并触发订阅者
+ * ```
+ * 更多用法示例：
+ *
+ * 1) 对象参数（只读 getter）：
+ * ```javascript
+ * const { createSignal, createComputed, createEffect } = wasmModule;
+ * const first = createSignal('John');
+ * const last = createSignal('Doe');
+ * const fullName = createComputed({
+ *   get: () => first.get() + ' ' + last.get()
+ * });
+ * createEffect(() => {
+ *   console.log('fullName =', fullName.get()); // John Doe
+ * });
+ * ```
+ *
+ * 2) 通过更新源信号实现“可写效果”（模拟 Vue3 的 setter 行为）：
+ * ```javascript
+ * const setFullName = (nv) => {
+ *   const [f, l] = nv.split(' ');
+ *   first.set(f);
+ *   last.set(l);
+ * };
+ * setFullName('David Smith'); // fullName 将变为 "David Smith"
+ * ```
+ *
+ * 3) 直接使用 `{ get, set }` 创建“可写 computed”，支持 `.set(value)`：
+ * ```javascript
+ * const fullName = createComputed({
+ *   get: () => first.get() + ' ' + last.get(),
+ *   set: (nv) => {
+ *     const [f, l] = nv.split(' ');
+ *     first.set(f);
+ *     last.set(l);
+ *   }
+ * });
+ * fullName.set('David Smith'); // 将调用你的 set 更新源信号，并重算派生值
+ * ```
+ */
+export function createComputed<T>(get: ComputedGetter<T>): ReadonlySignal<T>;
+export function createComputed<T>(options: ComputedOptions<T>): WritableSignal<T>;
+export function createComputed<T>(arg: ComputedGetter<T> | ComputedOptions<T>): ReadonlySignal<T> | WritableSignal<T>;
+
+
+
+/**
+ * 资源句柄：包含 `{ data, error, loading }` 三个信号
+ */
+export interface Resource<TData = any> {
+  data: SignalHandle;
+  error: SignalHandle;
+  loading: SignalHandle;
+}
+
+/**
+ * 创建资源：根据 `src` 信号的值调用 `fetcher`（返回 Promise），
+ * 并提供 `{ data, error, loading }` 三个信号以反映异步状态。
+ * 示例（JavaScript）：
+ * ```javascript
+ * const { createSignal, createResource, createEffect } = wasmModule;
+ * const key = createSignal('https://api.example.com/data');
+ * const res = createResource(key, async (k) => {
+ *   const r = await fetch(k);
+ *   if (!r.ok) throw new Error('network error');
+ *   return r.json();
+ * });
+ *
+ * createEffect(() => {
+ *   console.log('loading:', res.loading.get());
+ *   console.log('data:', res.data.get());
+ *   console.log('error:', res.error.get());
+ * });
+ *
+ * key.set('https://api.example.com/data2');
+ * ```
+ */
+export function createResource<TSrc, TData>(
+  src: SignalHandle,
+  fetcher: (src: TSrc) => Promise<TData>,
+): Resource<TData>;
+
+
+
+export class EffectHandle {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * 销毁副作用：标记为已处置，并清空其清理回调
+   *
+   * 用法（JavaScript）：
+   * ```js
+   * const eh = createEffect(() => {
+   *   // ...effect body
+   *   onCleanup(() => {
+   *     // 这里注册的清理会在下一次执行前或 dispose() 时运行
+   *   })
+   * })
+   * // 需要停止该副作用时：
+   * eh.dispose() // 标记为已处置，并执行最后一次已注册的清理
+   * ```
+   */
+  dispose(): void;
+}
+
+export class SignalHandle {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * 根据路径读取当前对象/数组的子项值（依赖收集）
+   *
+   * 用法（JavaScript）：
+   * ```js
+   * const s = createSignal({ user: { profile: { name: 'A' } } })
+   * const name1 = s.getPath(['user','profile','name']) // 'A'
+   * const name2 = s.getPath('user.profile.name') // 'A'
+   * // 在 watch 中使用路径读取会自动依赖收集
+   * watchFn(() => s.getPath(['user','profile','name']), (n, o) => {  })
+   * watchFn(() => s.getPath('user.profile.name'), (n, o) => {  })
+   * ```
+   */
+  getPath(path: any): any;
+  /**
+   * 根据路径设置对象/数组的子项值：不可变更新，生成新的根对象并触发订阅者
+   *
+   * 用法（JavaScript）：
+   * ```js
+   * const s = createSignal({ user: { profile: { name: 'A' }, age: 20 }, items: ['x'] })
+   * // 设置嵌套对象字段（数组路径）
+   * s.setPath(['user', 'profile', 'name'], 'B')
+   * // 设置数组元素（数组路径）
+   * s.setPath(['items', 0], 'y')
+   * // 字符串路径（以 . 分隔，数字段转为数组索引）
+   * s.setPath('user.profile.name', 'B')
+   * s.setPath('items.0', 'y')
+   * // 若根不是对象/数组，会以空对象作为根进行赋值
+   * s.setPath(['foo', 'bar'], 1)
+   * s.setPath('foo.bar', 1)
+   * ```
+   *
+   * 参数：
+   * - `path`: JS 数组或以 `.` 分隔的字符串（如 `['user','profile','name']`、`['items', 0]` 或 `'user.profile.name'`、`'items.0'`）
+   * - `value`: 目标路径的新值
+   * 行为与边界：
+   * - 路径缺失会自动以空对象占位，数组越界写入会扩展长度
+   * - 根为非对象/数组时以空对象为根进行赋值
+   * - 函数值作为普通值读写，不会被执行
+   */
+  setPath(path: any, value: any): void;
+  /**
+   * 便于调试：`signal.valueOf()` 返回内部值
+   */
+  valueOf(): any;
+  /**
+   * 路径偷看：不进行依赖收集（不订阅当前副作用），仅返回当前路径的值
+   * - 支持以 `.` 分隔的字符串路径（如 `user.profile.name`）或数组路径（如 `['user','profile','name']`、`['items', 0]`）
+   * - 行为与 `getPath` 相同，但不会触发依赖收集，适合用于调试/序列化
+   */
+  peekPath(path: any): any;
+  /**
+   * 便于调试：`String(signal)` 返回值的 JSON 字符串或占位文本
+   */
+  toString(): string;
+  /**
+   * 根据路径函数式更新子项：`updater(currentAtPath) -> nextAtPath`
+   *
+   * 用法（JavaScript）：
+   * ```js
+   * const s = createSignal({ user: { age: 20 }, items: ['x'] })
+   * s.updatePath(['user','age'], prev => prev + 1) // age: 21
+   * s.updatePath(['user','name'], prev => (prev || '').toUpperCase())
+   * // 使用字符串路径
+   * s.updatePath('user.age', prev => prev + 1) // age: 21
+   * s.updatePath('items.0', prev => (prev || '').toUpperCase())
+   * ```
+   */
+  updatePath(path: any, updater: Function): void;
+  /**
+   * 读取当前值，并在有正在运行的副作用时将其订阅到该信号
+   */
+  get(): any;
+  /**
+   * 设置新值，按等值比较决定是否通知订阅者
+   */
+  set(v: any): void;
+  /**
+   * 偷看当前值：不进行依赖收集（不订阅当前副作用）
+   */
+  peek(): any;
+  /**
+   * 便于调试：`JSON.stringify(signal)` 时返回内部值
+   */
+  toJSON(): any;
+  /**
+   * 根据回调对当前值进行计算并设置（相当于 set( updater(current) )）
+   */
+  update(updater: Function): void;
+  /**
+   * 只读调试：`signal.value` 直接返回内部值（不进行依赖收集）
+   */
+  value: any;
+}
+
+export class WasmRue {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  onCreated(f: any): void;
+  onMounted(f: any): void;
+  onUpdated(f: any): void;
+  /**
+   * 使用插件：将 options 归一化为 Vec<JsValue> 并调用内部 use_plugin
+   */
+  use(plugin: any, options: any): void;
+  onUnmounted(f: any): void;
+  /**
+   * 创建元素/组件的 VNode（开发态对象或注册表引用）
+   *
+   * - 组件函数：构建 Component 类型并输出注册表 ID
+   * - 普通标签：构建 VNodeType，归一化 children，入注册表或内联对象
+   */
+  createElement(type_tag: any, props: any, children: any): any;
+  /**
+   * 区间渲染入口：解析 id/函数组件/对象为 VNode，并提交区间信息
+   */
+  renderBetween(vnode_id: any, parent: any, start: any, end: any): void;
+  /**
+   * 读取当前 DOM 适配器（从全局 __rue_dom）
+   */
+  getDOMAdapter(): any;
+  onBeforeMount(f: any): void;
+  /**
+   * 设置 DOM 适配器（JsDomAdapter），用于后续渲染与元素操作
+   */
+  setDOMAdapter(adapter: any): void;
+  onBeforeCreate(f: any): void;
+  onBeforeUpdate(f: any): void;
+  onBeforeUnmount(f: any): void;
+  /**
+   * 获取 DOM 适配器的“可变”接口（同只读返回，兼容 JS 侧命名）
+   */
+  getDOMAdapterMut(): any;
+  /**
+   * JSX/h 入口：与 createElement 行为一致，聚合到同一实现
+   */
+  h(type_tag: any, props: any, children: any): any;
+  /**
+   * 获取当前容器：优先返回最近一次渲染或挂载设置的容器
+   */
+  getCurrentContainer(): any;
+  /**
+   * 挂载入口：预刷新延迟任务 → 调用 app → 回退到空片段
+   */
+  mount(app: any, container: any): void;
+  /**
+   * 返回 Vapor/VaporWithSetup 的注册表对象
+   *
+   * - 若传入 setup 函数：构建 VaporWithSetup，并尝试立即调用以填充 el
+   * - 若 el 为片段：收集其子节点并写入 __fragNodes
+   * - 否则构建普通 Vapor VNode
+   */
+  vapor(setup: any): any;
+  /**
+   * 渲染入口：接受 id/对象/vaporElement，解析为 VNode 并异步提交
+   */
+  render(vnode_id: any, container: any): void;
+  /**
+   * 返回一个 JS 回调函数，用于在组件内部发射事件
+   *
+   * - 根据 props 构建事件发射器 emitter(name, args)
+   * - 回调参数 args 若为数组，将其拆解为 Vec<JsValue> 传入
+   */
+  emitted(props: any): any;
+  /**
+   * 卸载入口：清空容器 innerHTML，并解除 container_map 绑定
+   */
+  unmount(container: any): void;
+  onError(f: any): void;
+}
+
+/**
+ * 批量更新：在回调期间抑制副作用的即时触发，统一在结束后刷新
+ *
+ * 用法与示例（JavaScript）：
+ * ```js
+ * const { createSignal, createEffect, batch } = wasmModule
+ *
+ * // 示例一：同一信号多次 set，仅在批量结束后重跑一次
+ * const count = createSignal(0)
+ * createEffect(() => {
+ *   console.log('[batch-demo] count =', count.get())
+ * })
+ * batch(() => {
+ *   count.set(1)
+ *   count.set(2)
+ *   count.set(3)
+ *   // 在批量范围内不会立即触发副作用
+ * })
+ * // 批量结束后只触发一次副作用，打印最新值 3
+ *
+ * // 示例二：一次性更新多个信号，副作用只合并重跑一次
+ * const a = createSignal(0)
+ * const b = createSignal(0)
+ * createEffect(() => {
+ *   console.log('[batch-demo] sum =', a.get() + b.get())
+ * })
+ * batch(() => {
+ *   a.set(10)
+ *   b.set(20)
+ * }) // 仅一次重跑，输出 sum = 30
+ * ```
+ */
+export function batch(cb: Function): void;
+
+export function computed(arg: any, force_global?: boolean | null): SignalHandle;
+
+/**
+ * 创建计算属性
+ * - 参数：可为函数 `() => any`，或对象 `{ get: () => any }`
+ * 返回：一个只读信号句柄（通过 get/peek 读取，内部通过 effect 驱动更新）
+ * 示例（JavaScript）：
+ * ```javascript
+ * const { createSignal, createComputed, createEffect } = wasmModule;
+ * const count = createSignal(1);
+ * const double = createComputed(() => count.get() * 2);
+ *
+ * createEffect(() => {
+ *   console.log('double =', double.get());
+ * });
+ *
+ * count.set(2); // double 将变为 4 并触发订阅者
+ * ```
+ * 更多用法示例：
+ *
+ * 1) 对象参数（只读 getter）：
+ * ```javascript
+ * const { createSignal, createComputed, createEffect } = wasmModule;
+ * const first = createSignal('John');
+ * const last = createSignal('Doe');
+ * const fullName = createComputed({
+ *   get: () => first.get() + ' ' + last.get()
+ * });
+ * createEffect(() => {
+ *   console.log('fullName =', fullName.get()); // John Doe
+ * });
+ * ```
+ *
+ * 2) 通过更新源信号实现“可写效果”（模拟 Vue3 的 setter 行为）：
+ * ```javascript
+ * const setFullName = (nv) => {
+ *   const [f, l] = nv.split(' ');
+ *   first.set(f);
+ *   last.set(l);
+ * };
+ * setFullName('David Smith'); // fullName 将变为 "David Smith"
+ * ```
+ *
+ * 3) 直接使用 `{ get, set }` 创建“可写 computed”，支持 `.set(value)`：
+ * ```javascript
+ * const fullName = createComputed({
+ *   get: () => first.get() + ' ' + last.get(),
+ *   set: (nv) => {
+ *     const [f, l] = nv.split(' ');
+ *     first.set(f);
+ *     last.set(l);
+ *   }
+ * });
+ * fullName.set('David Smith'); // 将调用你的 set 更新源信号，并重算派生值
+ * ```
+ */
+export function createComputed(arg: any): SignalHandle;
+
+/**
+ * 创建副作用（立即运行一次），并返回句柄
+ * 示例（JavaScript）：
+ * ```javascript
+ * const { createSignal, createEffect, onCleanup, untrack, batch } = wasmModule;
+ * const s = createSignal(0);
+ *
+ * // 基本副作用：读取信号并打印
+ * createEffect(() => {
+ *   console.log('value:', s.get());
+ * });
+ * s.set(1);
+ *
+ * // 清理示例：注册定时器并在下一次运行前清理
+ * createEffect(() => {
+ *   const id = setInterval(() => console.log('tick'), 1000);
+ *   onCleanup(() => clearInterval(id));
+ * });
+ *
+ * // 断开依赖收集：不会订阅 other 信号
+ * createEffect(() => {
+ *   const v = untrack(() => s.get());
+ *   console.log('untracked:', v);
+ * });
+ *
+ * 创建副作用（支持自定义调度器与懒执行）
+ * options:
+ * - scheduler: Function( run: Function )，用于自定义何时调用 run
+ * - lazy: bool，true 时不在创建时立即运行
+ * 示例（JavaScript）：
+ * ```javascript
+ * const { createEffect } = wasmModule;
+ * const scheduler = (run) => queueMicrotask(run); // 或者使用 requestAnimationFrame
+ * createEffect(() => {
+ *   // ...effect body
+ * }, { scheduler, lazy: false });
+ * ```
+ */
+export function createEffect(cb: Function, options?: any | null): EffectHandle;
+
+/**
+ * 创建 Reactive：返回一个对象/数组的响应式代理（深/浅、只读可选）
+ *
+ * 用法（JavaScript / TypeScript）：
+ * ```ts
+ * // 基础对象：读取与写入都响应式
+ * const state = createReactive({ user: { name: 'A' }, items: ['x'] })
+ * console.log(state.user.name)     // 'A'
+ * state.user.name = 'B'            // 写入嵌套字段，触发订阅者
+ * state.items.push('y')            // 数组写入也可触发（通过路径写入实现不可变更新）
+ *
+ * // 在 Vapor JSX 中使用（自动 DOM 更新）
+ * // <span>{state.user.name}</span>
+ * // <input value={state.user.name} onInput={e => state.user.name = e.target.value} />
+ *
+ * // 只读代理：禁止写入
+ * const ro = createReactive({ a: 1 }, { readonly: true })
+ * // ro.a = 2 // 将被忽略或导致失败（只读）
+ *
+ * // 浅代理：仅对顶层对象进行代理，子对象不递归代理
+ * const sh = createReactive({ nested: { a: 1 } }, { shallow: true })
+ * // sh.nested 仍为普通对象（非代理）
+ *
+ * // 原始类型：普通值会自动包裹为 { value } 并返回其代理
+ * const num = createReactive(0)
+ * console.log(num.value)       // 0
+ * num.value = 1               // 写入 value 字段触发订阅者
+ * const str = createReactive('A')
+ * str.value = 'B'             // 原始类型统一通过 value 字段读写
+ *
+ * // 自定义等值比较：用于控制触发频率
+ * const eq = (prev: any, next: any) => _.isEqual(prev, next)
+ * const obj = createReactive({ a: 1 }, { equals: eq })
+ * obj.a = 1 // 不触发（相等）
+ * ```
+ */
+export function createReactive(initial: any, options?: any | null): any;
+
+/**
+ * 创建 Ref：返回一个带有 `value` 字段的响应式代理对象
+ *
+ * 用法（JavaScript / TypeScript）：
+ * ```ts
+ * // 基本使用：读写 value，自动依赖收集
+ * const r = createRef(0)
+ * console.log(r.value)        // 0
+ * r.value = 1                 // 触发订阅者
+ *
+ * // 与 watchEffect 配合（依赖自动收集）
+ * const stop = watchEffect(() => {
+ *   console.log('ref value =', r.value)
+ * })
+ * r.value = 2                 // 触发前面的 watchEffect
+ * stop()                      // 停止响应
+ *
+ * // peek：查看当前值，不收集依赖（不会订阅当前副作用）
+ * const cur = r.peek()        // 仅返回值，不产生订阅
+ *
+ * // update：基于当前值计算并写回
+ * r.update(prev => prev + 1)  // 等价于 r.value = (prev + 1)
+ *
+ * // 自定义等值比较：避免无意义的触发
+ * const r2 = createRef({ a: 1 }, { equals: (p, n) => _.isEqual(p?.value, n?.value) })
+ * r2.value = { a: 1 }         // 不触发（相等）
+ *
+ * // 与组件/DOM 结合（Vapor 模式下自动更新）
+ * // <span>{r.value}</span> 会被编译为原生 DOM + 响应式更新
+ * ```
+ */
+export function createRef(initial: any, options?: any | null): any;
+
+/**
+ * 创建资源：根据 `src` 信号的值调用 `fetcher`（返回 Promise），
+ * 并提供 `{ data, error, loading }` 三个信号以反映异步状态。
+ * 示例（JavaScript）：
+ * ```javascript
+ * const { createSignal, createResource, createEffect } = wasmModule;
+ * const key = createSignal('https://api.example.com/data');
+ * const res = createResource(key, async (k) => {
+ *   const r = await fetch(k);
+ *   if (!r.ok) throw new Error('network error');
+ *   return r.json();
+ * });
+ *
+ * createEffect(() => {
+ *   console.log('loading:', res.loading.get());
+ *   console.log('data:', res.data.get());
+ *   console.log('error:', res.error.get());
+ * });
+ *
+ * key.set('https://api.example.com/data2');
+ * ```
+ */
+export function createResource(src: SignalHandle, fetcher: Function): any;
+
+/**
+ * 创建 WasmRue 实例（可选设置 DOM 适配器）
+ *
+ * - 若传入 adapter（JS 对象），则设置为 DomAdapter，并在全局挂载 __rue_dom
+ * - 初始化内部 Rue，构造渲染队列与上次容器记录
+ */
+export function createRue(adapter: any): WasmRue;
+
+/**
+ * 创建带选项的信号
+ * options.equals: Function(prev, next) -> bool，返回 true 表示值相等（不触发）
+ * 示例（JavaScript）：
+ * ```javascript
+ * const { createSignal, createEffect } = wasmModule;
+ * const count = createSignal(0);
+ * createEffect(() => {
+ *   console.log('count =', count.get());
+ * });
+ * count.set(1); // 触发 effect
+ *
+ * const eq = (prev, next) => prev === next;
+ * const s = createSignal(0, { equals: eq });
+ * s.set(0); // 不触发，因为 equals 返回 true（相等）
+ * s.set(2); // 触发订阅者
+ * ```
+ */
+export function createSignal(initial: any, options?: any | null): SignalHandle;
+
+/**
+ * 获取当前实例；若未设置则返回空值（null/undefined），不再构造默认根实例
+ * 用法（JavaScript）：
+ * ```javascript
+ * const { setCurrentInstance, getCurrentInstance, withHookSlot } = wasmModule;
+ *
+ * // 设置并获取当前实例
+ * setCurrentInstance({ name: 'A' });
+ * const inst = getCurrentInstance(); // { name: 'A', ... }
+ *
+ * // 清空当前实例后，获取为空（undefined 或 null）
+ * setCurrentInstance(undefined);
+ * const none = getCurrentInstance(); // undefined（或 null）
+ *
+ * // 在有当前实例时，withHookSlot 为该实例分配/复用一个 Hook 插槽
+ * setCurrentInstance({});
+ * const state = withHookSlot(() => ({ count: 0 })); // 首次创建并缓存到 __hooks.states
+ * ```
+ */
+export function getCurrentInstance(): any;
+
+export function isReactive(obj: any): boolean;
+
+/**
+ * 在当前运行的副作用上注册清理函数
+ * 清理函数会在下一次该副作用执行之前被调用
+ * 用法与示例（JavaScript）：
+ * ```js
+ * // 需求：每次依赖变化时重建一个定时器，并在下一次运行前清理上一次的定时器
+ * const s = createSignal(0)
+ * const eh = createEffect(() => {
+ *   const v = s.get() // 建立订阅
+ *   const id = setInterval(() => console.log('[onCleanup-demo] tick v=', v), 500)
+ *   onCleanup(() => clearInterval(id)) // 下次运行前清理上一次的定时器
+ * })
+ * s.set(1) // 触发重跑：先清理旧定时器，再创建新定时器（只保留一个）
+ * s.set(2) // 同理
+ * eh.dispose() // 停止后续运行，并执行最后一次已注册的清理（定时器不再 tick）
+ * ```
+ */
+export function onCleanup(cb: Function): void;
+
+export function propsReactive(initial: any, force_global?: boolean | null): any;
+
+export function reactive(initial: any, options?: any | null, force_global?: boolean | null): any;
+
+export function readonly(initial: any, force_global?: boolean | null): any;
+
+export function ref(initial: any, options?: any | null, force_global?: boolean | null): any;
+
+/**
+ * 设置当前实例
+ * 传入 `null/undefined` 表示清空；否则记录为 Some(instance)
+ * 示例（JavaScript）：
+ * ```javascript
+ * const { setCurrentInstance, getCurrentInstance, withHookSlot, createSignal } = wasmModule;
+ * const inst = { name: 'MyComponent' };
+ * setCurrentInstance(inst);
+ *
+ * // 在实例上分配一个 Hook 插槽，用于存储状态对象
+ * const state = withHookSlot(() => ({ count: createSignal(0) }));
+ * console.log(getCurrentInstance()); // 当前实例或根实例
+ * ```
+ */
+export function setCurrentInstance(i: any): void;
+
+/**
+ * 设置调度模式
+ * - mode="sync"：信号变更时尽可能同步触发副作用
+ * - 其他值：采用默认微任务合并调度
+ * 示例（JavaScript）：
+ * ```javascript
+ * const { setReactiveScheduling } = wasmModule;
+ * setReactiveScheduling('sync'); // 适合少量、快速的更新
+ * // setReactiveScheduling('microtask'); // 使用默认微任务合并（传非 "sync" 即可）
+ * ```
+ */
+export function setReactiveScheduling(mode: string): void;
+
+export function shallowReactive(initial: any, options?: any | null, force_global?: boolean | null): any;
+
+export function shallowReadonly(initial: any, force_global?: boolean | null): any;
+
+export function signal(initial: any, options?: any | null, force_global?: boolean | null): SignalHandle;
+
+export function toRaw(obj: any): any;
+
+/**
+ * 通用取值转换
+ * 支持以下输入：
+ * - 函数：调用并返回其结果
+ * - 对象：优先读取 `value` 字段，其次尝试调用 `get()` 方法
+ * - 其他：直接返回原值
+ * 示例（JavaScript）：
+ * ```javascript
+ * const { toValue } = wasmModule;
+ * toValue(() => 1); // 1
+ * toValue({ value: 2 }); // 2
+ * toValue({ get() { return 3; } }); // 3
+ * toValue('hello'); // 'hello'
+ * ```
+ */
+export function toValue(x: any): any;
+
+export function unref(obj: any): any;
+
+/**
+ * 断开依赖收集地执行回调（不记录对 Signal 的订阅）
+ *
+ * 用途与示例（JavaScript）：
+ * - 在同一个副作用中，订阅主依赖 `a`，但临时读取 `b` 并且不希望 `b` 的变化触发该副作用。
+ * - `untrack(fn)` 会在执行 `fn` 时临时关闭依赖收集，`fn` 内部对信号的读取不会把当前副作用订阅到这些信号上。
+ *
+ * ```js
+ * const a = createSignal(0)
+ * const b = createSignal(0)
+ * createEffect(() => {
+ *   const av = a.get()                // 订阅 a：a 变化会使该副作用重跑
+ *   const bv = untrack(() => b.get()) // 断开依赖读取 b：b 变化不会触发该副作用
+ *   console.log('[untrack-demo] run av=', av, 'bv=', bv)
+ * })
+ * b.set(1)  // 不触发副作用（因为对 b 的读取发生在 untrack 内）
+ * b.set(2)  // 不触发副作用
+ * a.set(10) // 触发副作用（因为对 a 进行了正常订阅）
+ * ```
+ *
+ * 说明：若仅需“不订阅地读取”某个信号，也可使用 `peek()`（例如 `const v = sig.peek()`）。
+ */
+export function untrack(cb: Function): any;
+
+export function useCallback(func: Function, deps: any): Function;
+
+export function useEffect(effect: Function, deps?: any | null, options?: any | null): void;
+
+export function useMemo(factory: Function, deps: any): any;
+
+export function useRef(initial: any): any;
+
+export function useSetup(factory: Function): any;
+
+/**
+ * useSignal：等价于 `useState(initial, { kind: 'signal', ...options })`
+ *
+ * 用途：
+ * - 以“底层信号句柄”的形式管理状态，适合需要精细控制 `get/set/update/setPath/peek` 的场景
+ * - 支持 `equals(prev, next)` 自定义等值比较，返回 `true` 表示不触发订阅者
+ *
+ * 示例：
+ * const [sig, setSig] = useSignal({ a: 1 })
+ * console.log(sig.get())       // { a: 1 }
+ * setSig({ a: 2 })             // 触发订阅者
+ * setSig(h => ({ a: h.peek().a + 1 })) // { a: 3 }
+ * sig.setPath('a', 4)
+ * console.log(sig.get())       // { a: 4 }
+ */
+export function useSignal(initial: any, options?: any | null): any;
+
+/**
+ * useState 钩子：统一的轻量状态容器（支持 reactive/ref/signal 三种形态）
+ *
+ * 设计概览：
+ * - 默认形态为 `reactive`：当初始值为对象/数组时直接返回其响应式代理；当为原始类型时自动包裹为 `{ value }` 并返回其代理。
+ * - 可选 `kind`：
+ *   - `'reactive'`：对象/数组的响应式代理；原始类型将自动包裹为 `{ value }`
+ *   - `'ref'`：总是返回 `{ value }` 的响应式代理，便于统一读写
+ *   - `'signal'`：返回底层 `SignalHandle`，适合需要精细控制 get/set/update/path 的场景
+ * - 等值比较：通过 `options.equals(prev, next)` 自定义比较逻辑，返回 `true` 表示值相等，不触发订阅者。
+ *
+ * 使用示例（JavaScript / TypeScript）：
+ * // reactive（默认）
+ * const [state, setState] = useState({ user: { name: 'A' }, items: ['x'] })
+ * state.user.name = 'B'        // 响应式写入
+ * setState({ user: { name: 'C' }, items: ['y'] })  // 整体替换
+ * setState(prev => ({ ...prev, user: { ...prev.user, name: 'D' } })) // 基于回调更新
+ *
+ * // ref（原始类型亦可统一为 { value }）
+ * const [count, setCount] = useState(0, { kind: 'ref' })
+ * console.log(count.value)     // 0
+ * setCount(1)                  // 触发订阅者
+ * setCount(ref => { ref.value += 1 }) // 2
+ *
+ * // signal（底层句柄）
+ * const [sig, setSig] = useState({ a: 1 }, { kind: 'signal' })
+ * console.log(sig.get())       // { a: 1 }
+ * sig.set({ a: 2 })            // 触发订阅者
+ * setSig(handle => ({ a: handle.peek().a + 1 })) // { a: 3 }
+ * sig.setPath('a', 4)          // 路径写入
+ * console.log(sig.get())       // { a: 4 }
+ *
+ * // 自定义等值比较（默认使用 shallowEqual）
+ * const [state2, setState2] = useState({ a: 1, b: 2 }, { kind: 'reactive', equals: (prev, next) => prev.a === next.a })
+ * setState2({ a: 1, b: 3 })   // 不触发订阅者，因为 a 未改变
+ * setState2({ a: 2, b: 4 })   // 触发订阅者，因为 a 改变
+ */
+export function useState(initial: any, options?: any | null): any;
+
+/**
+ * 按 Hook 唯一 id 绑定插槽索引并运行回调
+ * - 行为：在当前实例的 `__hooks.__idMap` 中为 `id` 分配稳定索引，并通过设置 `__forcedIndex` 强制 `withHookSlot` 使用该索引
+ * - 若此前不存在该 id，则使用 `states.length` 作为新索引
+ * - 运行 `runner()`，并在结束后清除 `__forcedIndex`
+ */
+export function vaporWithHookId(id: any, runner: Function): any;
+
+/**
+ * 统一侦听入口：接受函数、信号句柄对象（含 `get` 方法）或来源数组
+ *
+ * 用法（JavaScript）：
+ * ```js
+ * // 1) 侦听函数源（等价 watchFn）
+ * const stop1 = watch(() => state.count, (n, o) => { console.log(n, o) }, { immediate: true })
+ *
+ * // 2) 侦听信号句柄对象（含 get 方法）
+ * const s = createSignal(0)
+ * const stop2 = watch(s, (n, o) => { console.log(n, o) })
+ * s.set(1)
+ *
+ * // 3) 侦听来源数组：函数 / 信号句柄 / 常量混合
+ * const s1 = createSignal(0)
+ * const s2 = createSignal(10)
+ * const stop3 = watch([() => s1.get(), s2, 'x'], ([n1, n2, c], [o1, o2, oc]) => { console.log(n1, n2, c, o1, o2, oc) })
+ * s1.set(1); s2.set(11)
+ *
+ * // 自定义比较：覆盖默认逐项浅比较
+ * watch([s1, s2], (n, o) => {}, { equals: (prev, next) => _.isEqual(prev, next) })
+ * ```
+ */
+export function watch(source: any, handler: Function, options_raw?: any | null): EffectHandle;
+
+/**
+ * 深度侦听：当对象/数组任意子项变化时触发
+ *
+ * 用法（JavaScript）：
+ * ```js
+ * const s = createSignal({ user: { name: 'A' }, items: ['x'] })
+ * const stop = watchDeepSignal(s, (newv, oldv) => {
+ *   console.log('deep changed', oldv, '->', newv)
+ * }, { immediate: true })
+ * s.setPath(['user','name'], 'B')
+ * s.setPath(['items', 0], 'y')
+ * stop.dispose() // 取消侦听
+ * ```
+ */
+export function watchDeepSignal(src: SignalHandle, handler: Function, options?: any | null): EffectHandle;
+
+/**
+ * 侦听副作用：在副作用体内自行读取信号，依赖会自动收集
+ * 类似 Vue 的 `watchEffect`
+ * 示例（JavaScript）：
+ * ```javascript
+ * const { createSignal, watchEffect } = wasmModule;
+ * const s = createSignal(0);
+ * watchEffect(() => {
+ *   console.log('value:', s.get());
+ * }, {
+ *     //可选 scheduler
+ * });
+ * s.set(1);
+ * ```
+ */
+export function watchEffect(cb: Function, options?: any | null): EffectHandle;
+
+/**
+ * 侦听任意 getter 函数的结果变化
+ * options: { immediate?: bool, scheduler?: Function, equals?: Function }
+ * 示例（JavaScript）：
+ * ```javascript
+ * const { watchFn } = wasmModule;
+ * const obj = { value: 0 };
+ * const stop = watchFn(
+ *   () => obj.value,
+ *   (newv, oldv) => console.log('changed:', oldv, '->', newv),
+ *   { immediate: true }
+ * );
+ * obj.value = 1; // 当 getter 读取到新值时触发 handler
+ * ```
+ */
+export function watchFn(getter: Function, handler: Function, options?: any | null): EffectHandle;
+
+/**
+ * 侦听指定路径的值变化：`path` 支持 JS 数组或以 `.` 分隔的字符串
+ *
+ * 用法（JavaScript）：
+ * ```js
+ * const s = createSignal({ user: { profile: { name: 'A' } } })
+ * // 数组路径
+ * watchPath(s, ['user','profile','name'], (n, o) => {
+ *   console.log('name changed:', o, '->', n)
+ * }, { immediate: true })
+ * // 字符串路径（数字段会自动转为数组索引）
+ * watchPath(s, 'user.profile.name', (n, o) => {
+ *   console.log('name changed:', o, '->', n)
+ * }, { immediate: true })
+ * s.setPath(['user','profile','name'], 'B')
+ * s.setPath('user.profile.name', 'B')
+ * ```
+ */
+export function watchPath(src: SignalHandle, path: any, handler: Function, options?: any | null): EffectHandle;
+
+/**
+ * 侦听单个信号的变化并在变化时触发处理器
+ * options: { immediate?: bool, scheduler?: Function, equals?: Function }
+ * 示例（JavaScript）：
+ * ```javascript
+ * const { createSignal, watchSignal } = wasmModule;
+ * const s = createSignal(0);
+ * watchSignal(s, (newv, oldv) => {
+ *   console.log('signal changed:', oldv, '->', newv);
+ * }, { immediate: true });
+ * s.set(1);
+ * ```
+ */
+export function watchSignal(src: SignalHandle, handler: Function, options?: any | null): EffectHandle;
+
+/**
+ * 在当前实例上为 Hook 分配/复用一个插槽
+ * - 若无当前实例，则直接执行 factory 返回对象
+ * - 有实例时，依据 `__hooks.index` 或 `__forcedIndex` 计算插槽序号
+ * 示例（JavaScript）：
+ * ```javascript
+ * const { setCurrentInstance, withHookSlot } = wasmModule;
+ * setCurrentInstance({});
+ * const a = withHookSlot(() => ({ id: 1 }));
+ * const b = withHookSlot(() => ({ id: 2 }));
+ * // 若再次调用 withHookSlot（且未强制索引），将分配下一个插槽
+ * ```
+ */
+export function withHookSlot(factory: Function): any;