diff --git a/package.json b/package.json
index 0dafb91..2b13457 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "regor",
-  "version": "1.3.1",
+  "version": "1.3.2",
   "description": "A modern UI framework for web and desktop applications, inspired by Vue's concepts and powered by simplicity and flexibility.",
   "author": "Ahmed Yasin Koculu",
   "license": "MIT",
diff --git a/src/api/types.ts b/src/api/types.ts
index 1910cd1..e0ac0fc 100644
--- a/src/api/types.ts
+++ b/src/api/types.ts
@@ -28,30 +28,29 @@ type RawTypes =
   | Promise<unknown>
   | Error
 
-declare const RefSymbol: unique symbol
-
 declare const RawSymbol: unique symbol
 
 declare const ScopeSymbol: unique symbol
 
-export type AnyRef = (
-  newValue?: any,
-  eventSource?: any,
-) => any & { [RefSymbol]: true }
+type BivariantAnyRefCall = {
+  bivarianceHack(newValue?: unknown, eventSource?: unknown): unknown
+}['bivarianceHack']
+
+export type AnyRef = BivariantAnyRefCall
 
 export type Ref<TValueType> = ((
   newValue?:
     | RefContent<TValueType>
     | Ref<RefParam<TValueType>>
     | SRef<RefContent<TValueType>>,
-  eventSource?: any,
+  eventSource?: unknown,
 ) => RefContent<TValueType>) & {
   value: RefContent<TValueType>
 }
 
 export type SRef<TValueType> = ((
   newValue?: TValueType | SRef<TValueType>,
-  eventSource?: any,
+  eventSource?: unknown,
 ) => SRefContent<TValueType>) & {
   value: SRefContent<TValueType>
 }
@@ -155,7 +154,7 @@ export type Flat<TValueType> =
 
 export type ObserveCallback<TValueType> = (
   newValue: TValueType,
-  eventSource?: any,
+  eventSource?: unknown,
 ) => void
 
 export type StopObserving = () => void
@@ -182,10 +181,10 @@ export interface Directive {
   /** Called on every value change. */
   onChange?: (
     el: HTMLElement,
-    values: any[],
-    previousValues?: any[],
-    option?: any,
-    previousOption?: any,
+    values: unknown[],
+    previousValues?: unknown[],
+    option?: unknown,
+    previousOption?: unknown,
     flags?: string[],
   ) => void
 
@@ -339,7 +338,7 @@ export interface CreateComponentOptions<
    * The props defined in the props list can be used with :foo or r-bind:foo syntax.
    * `<MyComponent :prop-kebab-1="1" r-bind:prop-kebab-2="x ? 1 : 0" :props="{ propFoo3: true, propFoo4: x ? 'a' : 'b' }></MyComponent>`
    * It is required to define prop-kebab-1 and prop-kebab-2 in the props list camelized.
-   * It is not required to define propFoo3 and propFoo4 in the props list because it uses :props binding. :props binding enables binding to any property of component regardless it is explicitly defined in props list.
+   * It is not required to define propFoo3 and propFoo4 in the props list because it uses :props binding. :props binding enables binding to arbitrary component properties regardless they are explicitly defined in props list.
    */
   props?: string[]
 
@@ -369,10 +368,10 @@ export interface ComposableScope {
  */
 export type SRefSignature<TValueType> = (
   newValue?: TValueType,
-  eventSource?: any,
+  eventSource?: unknown,
   operation?: RefOperation,
   observer?: ObserveCallback<TValueType>,
-) => any
+) => unknown
 
 /**
  * @internal
diff --git a/src/cleanup/getBindData.ts b/src/cleanup/getBindData.ts
index c7d8162..42ea56e 100644
--- a/src/cleanup/getBindData.ts
+++ b/src/cleanup/getBindData.ts
@@ -1,13 +1,16 @@
 import { type BindData } from '../api/types'
 import { bindDataSymbol } from './bindDataSymbol'
 
-export const getBindData = (node: any): BindData => {
-  const bindData = node[bindDataSymbol]
+type BindableNode = { [bindDataSymbol]?: BindData }
+
+export const getBindData = (node: object): BindData => {
+  const bindableNode = node as BindableNode
+  const bindData = bindableNode[bindDataSymbol]
   if (bindData) return bindData as BindData
   const newBindData: BindData = {
     unbinders: [],
     data: {},
   }
-  node[bindDataSymbol] = newBindData
+  bindableNode[bindDataSymbol] = newBindData
   return newBindData
 }
diff --git a/src/computed/computeMany.ts b/src/computed/computeMany.ts
index df40a5d..8042b45 100644
--- a/src/computed/computeMany.ts
+++ b/src/computed/computeMany.ts
@@ -13,9 +13,16 @@ import { sref } from '../reactivity/sref'
 import { trigger } from '../reactivity/trigger'
 import { type ComputedOnce } from './computed'
 
-export const computeMany = <TReturnType>(
-  sources: AnyRef[],
-  compute: (...values: any[]) => TReturnType,
+type ComputeManySourceValues<TSources extends readonly AnyRef[]> = {
+  [TIndex in keyof TSources]: UnwrapRef<TSources[TIndex]>
+}
+
+export const computeMany = <
+  const TSources extends readonly AnyRef[],
+  TReturnType,
+>(
+  sources: TSources,
+  compute: (...values: ComputeManySourceValues<TSources>) => TReturnType,
 ): ComputedRef<UnwrapRef<TReturnType>> => {
   const status: ComputedOnce<TReturnType> = {}
   let computer: any
@@ -23,7 +30,7 @@ export const computeMany = <TReturnType>(
     if (args.length <= 2 && 0 in args)
       throw getError(ErrorType.ComputedIsReadOnly)
     if (computer && !status.isStopped) return computer(...args)
-    computer = computeManyOnce(sources, compute, status)
+    computer = computeManyOnce<TSources, TReturnType>(sources, compute, status)
     return computer(...args)
   }) as ComputedRef<UnwrapRef<TReturnType>>
 
@@ -34,9 +41,9 @@ export const computeMany = <TReturnType>(
   return result
 }
 
-const computeManyOnce = <TReturnType>(
-  sources: AnyRef[],
-  compute: (...values: any[]) => TReturnType,
+const computeManyOnce = <TSources extends readonly AnyRef[], TReturnType>(
+  sources: TSources,
+  compute: (...values: ComputeManySourceValues<TSources>) => TReturnType,
   status: ComputedOnce<TReturnType>,
 ): ComputedRef<UnwrapRef<TReturnType>> => {
   const result =
@@ -47,14 +54,17 @@ const computeManyOnce = <TReturnType>(
   status.ref = result
   status.isStopped = false
   let i = 0
-  const callback = (_: any): void => {
+  const callback = (_: unknown): void => {
     if (i > 0) {
       result.stop()
       status.isStopped = true
       trigger(result)
       return
     }
-    result(compute(...sources.map((x) => x())) as UnwrapRef<TReturnType>)
+    const values = sources.map((source) =>
+      source(),
+    ) as ComputeManySourceValues<TSources>
+    result(compute(...values) as UnwrapRef<TReturnType>)
     ++i
   }
   const stopObservingList: StopObserving[] = []
diff --git a/src/log/warnings.ts b/src/log/warnings.ts
index 53b4d2d..a3ea16e 100644
--- a/src/log/warnings.ts
+++ b/src/log/warnings.ts
@@ -62,4 +62,6 @@ export const warning = (type: WarningType, ...args: unknown[]): void => {
   else handler(item, ...item.args)
 }
 
-export const warningHandler = { warning: console.warn }
+export const warningHandler: { warning: (...data: unknown[]) => void } = {
+  warning: console.warn,
+}
diff --git a/src/misc/isRaw.ts b/src/misc/isRaw.ts
index 85a6b48..aa08fbe 100644
--- a/src/misc/isRaw.ts
+++ b/src/misc/isRaw.ts
@@ -1,5 +1,5 @@
 import { rawSymbol } from '../reactivity/refSymbols'
 
-export const isRaw = (value: any): boolean => {
-  return !!value && value[rawSymbol] === 1
+export const isRaw = (value: unknown): boolean => {
+  return !!value && (value as Record<symbol, unknown>)[rawSymbol] === 1
 }
diff --git a/src/misc/tagged-html.ts b/src/misc/tagged-html.ts
index f12f3d9..65b2123 100644
--- a/src/misc/tagged-html.ts
+++ b/src/misc/tagged-html.ts
@@ -1,6 +1,6 @@
 export const html = (
   templates: TemplateStringsArray,
-  ...args: any[]
+  ...args: unknown[]
 ): string => {
   let result = ''
   const tpl = templates
diff --git a/src/observer/observe.ts b/src/observer/observe.ts
index a9acbe2..76cb60b 100644
--- a/src/observer/observe.ts
+++ b/src/observer/observe.ts
@@ -17,7 +17,7 @@ export const observe = <TValueType extends AnyRef>(
 ): StopObserving => {
   if (!isRef(source))
     throw getError(ErrorType.RequiresRefSourceArgument, 'observe')
-  if (init) observer(source())
+  if (init) observer(source() as UnwrapRef<TValueType>)
   const srefImpl = source as unknown as SRefSignature<UnwrapRef<TValueType>>
   const stop = srefImpl(
     undefined,
diff --git a/src/observer/observeMany.ts b/src/observer/observeMany.ts
index bfa4560..7c9c698 100644
--- a/src/observer/observeMany.ts
+++ b/src/observer/observeMany.ts
@@ -1,19 +1,21 @@
-import {
-  type AnyRef,
-  type ObserveCallback,
-  type StopObserving,
-} from '../api/types'
+import { type AnyRef, type StopObserving, type UnwrapRef } from '../api/types'
 import { onUnmounted } from '../composition/onUnmounted'
 import { observe } from './observe'
 
-export const observeMany = (
-  sources: AnyRef[],
-  observer: ObserveCallback<any[]>,
+type ObserveManySourceValues<TSources extends readonly AnyRef[]> = {
+  [TIndex in keyof TSources]: UnwrapRef<TSources[TIndex]>
+}
+
+export const observeMany = <const TSources extends readonly AnyRef[]>(
+  sources: TSources,
+  observer: (values: ObserveManySourceValues<TSources>) => void,
   init?: boolean,
 ): StopObserving => {
   const stopObservingList: StopObserving[] = []
   const callObserver = (): void => {
-    observer(sources.map((y) => y()))
+    observer(
+      sources.map((source) => source()) as ObserveManySourceValues<TSources>,
+    )
   }
   for (const source of sources) {
     stopObservingList.push(observe(source, callObserver))
diff --git a/src/parser/regorEval.ts b/src/parser/regorEval.ts
index aedb0d3..2af0726 100644
--- a/src/parser/regorEval.ts
+++ b/src/parser/regorEval.ts
@@ -108,7 +108,7 @@ const evalPrefixUpdate = {
   '++': (context: Context, key: any) => {
     const v = context[key]
     if (isRef(v)) {
-      let r = v()
+      let r = v() as any
       v(++r)
       return r
     }
@@ -117,7 +117,7 @@ const evalPrefixUpdate = {
   '--': (context: Context, key: any) => {
     const v = context[key]
     if (isRef(v)) {
-      let r = v()
+      let r = v() as any
       v(--r)
       return r
     }
@@ -129,7 +129,7 @@ const evalPostUpdate = {
   '++': (context: Context, key: any) => {
     const v = context[key]
     if (isRef(v)) {
-      const r = v()
+      const r = v() as any
 
       v(r + 1)
       return r
@@ -139,7 +139,7 @@ const evalPostUpdate = {
   '--': (context: Context, key: any) => {
     const v = context[key]
     if (isRef(v)) {
-      const r = v()
+      const r = v() as any
       v(r - 1)
       return r
     }
@@ -157,7 +157,7 @@ const applyAssigment = {
   '+=': (context: Context, key: any, value: any) => {
     const v = context[key]
     if (isRef(v)) {
-      return v(v() + value)
+      return v((v() as any) + value)
     }
 
     return (context[key] += value)
@@ -165,77 +165,77 @@ const applyAssigment = {
   '-=': (context: Context, key: any, value: any) => {
     const v = context[key]
     if (isRef(v)) {
-      return v(v() - value)
+      return v((v() as any) - value)
     }
     return (context[key] -= value)
   },
   '*=': (context: Context, key: any, value: any) => {
     const v = context[key]
     if (isRef(v)) {
-      return v(v() * value)
+      return v((v() as any) * value)
     }
     return (context[key] *= value)
   },
   '/=': (context: Context, key: any, value: any) => {
     const v = context[key]
     if (isRef(v)) {
-      return v(v() / value)
+      return v((v() as any) / value)
     }
     return (context[key] /= value)
   },
   '%=': (context: Context, key: any, value: any) => {
     const v = context[key]
     if (isRef(v)) {
-      return v(v() % value)
+      return v((v() as any) % value)
     }
     return (context[key] %= value)
   },
   '**=': (context: Context, key: any, value: any) => {
     const v = context[key]
     if (isRef(v)) {
-      return v(v() ** value)
+      return v((v() as any) ** value)
     }
     return (context[key] **= value)
   },
   '<<=': (context: Context, key: any, value: any) => {
     const v = context[key]
     if (isRef(v)) {
-      return v(v() << value)
+      return v((v() as any) << value)
     }
     return (context[key] <<= value)
   },
   '>>=': (context: Context, key: any, value: any) => {
     const v = context[key]
     if (isRef(v)) {
-      return v(v() >> value)
+      return v((v() as any) >> value)
     }
     return (context[key] >>= value)
   },
   '>>>=': (context: Context, key: any, value: any) => {
     const v = context[key]
     if (isRef(v)) {
-      return v(v() >>> value)
+      return v((v() as any) >>> value)
     }
     return (context[key] >>>= value)
   },
   '|=': (context: Context, key: any, value: any) => {
     const v = context[key]
     if (isRef(v)) {
-      return v(v() | value)
+      return v((v() as any) | value)
     }
     return (context[key] |= value)
   },
   '&=': (context: Context, key: any, value: any) => {
     const v = context[key]
     if (isRef(v)) {
-      return v(v() & value)
+      return v((v() as any) & value)
     }
     return (context[key] &= value)
   },
   '^=': (context: Context, key: any, value: any) => {
     const v = context[key]
     if (isRef(v)) {
-      return v(v() ^ value)
+      return v((v() as any) ^ value)
     }
     return (context[key] ^= value)
   },
diff --git a/src/reactivity/sref.ts b/src/reactivity/sref.ts
index 124eab2..a0123f4 100644
--- a/src/reactivity/sref.ts
+++ b/src/reactivity/sref.ts
@@ -112,7 +112,7 @@ export const sref = <TValueType>(
       if (0 in args) {
         if (refObj._value === newValue) return newValue
         if (isRef(newValue)) {
-          newValue = newValue()
+          newValue = newValue() as TValueType
           if (refObj._value === newValue) return newValue
         }
 
diff --git a/src/reactivity/trigger.ts b/src/reactivity/trigger.ts
index 1df98b7..588116b 100644
--- a/src/reactivity/trigger.ts
+++ b/src/reactivity/trigger.ts
@@ -4,7 +4,7 @@ import { isRef } from './isRef'
 
 export const trigger = <TValueType extends AnyRef>(
   source: TValueType,
-  eventSource?: any,
+  eventSource?: unknown,
   isRecursive?: boolean,
 ): void => {
   if (!isRef(source)) return
diff --git a/tests/computed/computeMany.spec.ts b/tests/computed/computeMany.spec.ts
new file mode 100644
index 0000000..ce17962
--- /dev/null
+++ b/tests/computed/computeMany.spec.ts
@@ -0,0 +1,119 @@
+import { expect, test } from 'vitest'
+
+import { computeMany, ref, watchEffect } from '../../src'
+
+test('computeMany computes lazily and caches until a source changes', () => {
+  const a = ref(1)
+  const b = ref(2)
+  let calls = 0
+
+  const sum = computeMany([a, b], (x, y) => {
+    ++calls
+    return x + y
+  })
+
+  expect(calls).toBe(0)
+  expect(sum()).toBe(3)
+  expect(calls).toBe(1)
+
+  // no dependency change => cached result
+  expect(sum()).toBe(3)
+  expect(calls).toBe(1)
+
+  a(5)
+  expect(calls).toBe(1)
+  expect(sum()).toBe(7)
+  expect(calls).toBe(2)
+})
+
+test('computeMany uses latest source values after multiple changes before next read', () => {
+  const a = ref(1)
+  const b = ref(1)
+  let calls = 0
+
+  const sum = computeMany([a, b], (x, y) => {
+    ++calls
+    return x + y
+  })
+
+  expect(sum()).toBe(2)
+  expect(calls).toBe(1)
+
+  a(2)
+  a(3)
+  b(4)
+  b(5)
+
+  // recomputes once on next access with latest values
+  expect(sum()).toBe(8)
+  expect(calls).toBe(2)
+})
+
+test('computeMany notifies reactive consumers via watchEffect', () => {
+  const a = ref(1)
+  const b = ref(2)
+  const sum = computeMany([a, b], (x, y) => x + y)
+  const seen: number[] = []
+
+  const stop = watchEffect(() => {
+    seen.push(sum())
+  })
+
+  expect(seen).toStrictEqual([3])
+
+  a(4)
+  expect(seen).toStrictEqual([3, 6])
+
+  b(10)
+  expect(seen).toStrictEqual([3, 6, 14])
+
+  stop()
+})
+
+test('computeMany infers and computes with mixed primitive types', () => {
+  const name = ref('Alice')
+  const age = ref(30)
+  const active = ref(true)
+
+  const summary = computeMany([name, age, active], (n, a, isActive) => {
+    return `${n}-${a}-${isActive ? 'on' : 'off'}`
+  })
+
+  expect(summary()).toBe('Alice-30-on')
+
+  age(31)
+  active(false)
+  expect(summary()).toBe('Alice-31-off')
+})
+
+test('computeMany infers Date sources and reacts to replacement', () => {
+  const start = ref(new Date('2024-01-01T00:00:00.000Z'))
+  const end = ref(new Date('2024-01-03T00:00:00.000Z'))
+
+  const dayDiff = computeMany([start, end], (s, e) => {
+    const msPerDay = 24 * 60 * 60 * 1000
+    return Math.round((e.getTime() - s.getTime()) / msPerDay)
+  })
+
+  expect(dayDiff()).toBe(2)
+
+  end(new Date('2024-01-06T00:00:00.000Z'))
+  expect(dayDiff()).toBe(5)
+})
+
+test('computeMany infers tuple order for different source types', () => {
+  const title = ref('Report')
+  const count = ref(2)
+  const createdAt = ref(new Date('2025-05-10T00:00:00.000Z'))
+
+  const formatted = computeMany([title, count, createdAt], (t, c, d) => {
+    return `${t}#${c}@${d.getUTCFullYear()}`
+  })
+
+  expect(formatted()).toBe('Report#2@2025')
+
+  title('Summary')
+  count(3)
+  createdAt(new Date('2026-07-01T00:00:00.000Z'))
+  expect(formatted()).toBe('Summary#3@2026')
+})
diff --git a/tests/observer/observeMany.spec.ts b/tests/observer/observeMany.spec.ts
index 74ac92f..a0c6926 100644
--- a/tests/observer/observeMany.spec.ts
+++ b/tests/observer/observeMany.spec.ts
@@ -15,6 +15,45 @@ test('observeMany observes multiple refs', () => {
   stop()
 })
 
+test('observeMany infers tuple source types in callback', () => {
+  const label = ref('v1')
+  const count = ref(2)
+  const createdAt = ref(new Date('2025-01-01T00:00:00.000Z'))
+
+  const calls: string[] = []
+  const stop = observeMany(
+    [label, count, createdAt],
+    ([l, c, d]) => {
+      calls.push(`${l}:${c}:${d.getUTCFullYear()}`)
+    },
+    true,
+  )
+
+  expect(calls).toStrictEqual(['v1:2:2025'])
+
+  label('v2')
+  count(3)
+  createdAt(new Date('2026-01-01T00:00:00.000Z'))
+
+  expect(calls.at(-1)).toBe('v2:3:2026')
+  stop()
+})
+
+test('observeMany stop prevents further callback execution', () => {
+  const a = ref(1)
+  const b = ref(10)
+  const cb = vi.fn()
+  const stop = observeMany([a, b], cb, true)
+
+  expect(cb).toHaveBeenCalledTimes(1)
+
+  stop()
+  a(2)
+  b(11)
+
+  expect(cb).toHaveBeenCalledTimes(1)
+})
+
 test('observerCount tracks observers', () => {
   const r = ref(0)
   expect(observerCount(r)).toBe(0)
diff --git a/tests/reactivity/trigger.spec.ts b/tests/reactivity/trigger.spec.ts
new file mode 100644
index 0000000..7ebd71c
--- /dev/null
+++ b/tests/reactivity/trigger.spec.ts
@@ -0,0 +1,101 @@
+import { expect, test } from 'vitest'
+
+import { observe, ref, sref, trigger } from '../../src'
+
+test('trigger does nothing for non-ref values', () => {
+  expect(() => trigger(123 as never)).not.toThrow()
+  expect(() => trigger({ a: 1 } as never)).not.toThrow()
+})
+
+test('trigger notifies observers of the source ref', () => {
+  const state = ref({ count: 1 })
+  let calls = 0
+  let lastEventSource: unknown
+
+  observe(state, (_value, eventSource) => {
+    ++calls
+    lastEventSource = eventSource
+  })
+
+  const source = { reason: 'manual-trigger' }
+  trigger(state, source)
+
+  expect(calls).toBe(1)
+  expect(lastEventSource).toBe(source)
+})
+
+test('trigger with recursive=false does not notify nested refs', () => {
+  const child = ref(0)
+  const root = sref({ child })
+
+  let childCalls = 0
+  observe(child, (value) => {
+    const typed: number = value
+    expect(typed).toBe(0)
+    ++childCalls
+  })
+
+  trigger(root, undefined, false)
+  expect(childCalls).toBe(0)
+})
+
+test('trigger with recursive=true notifies nested refs in objects/arrays/sets/maps', () => {
+  const objectRef = ref(1)
+  const arrayRef = ref(2)
+  const setRef = ref(3)
+  const mapKeyRef = ref('k')
+  const mapValueRef = ref(4)
+  const arrContainer = sref([arrayRef])
+  const setContainer = sref(new Set([setRef]))
+  const mapContainer = sref(new Map([[mapKeyRef, mapValueRef]]))
+
+  const root = sref({
+    objectRef,
+    arrContainer,
+    setContainer,
+    mapContainer,
+  })
+
+  const calls = {
+    object: 0,
+    array: 0,
+    set: 0,
+    mapKey: 0,
+    mapValue: 0,
+  }
+  const eventSources: unknown[] = []
+
+  observe(objectRef, (_value, eventSource) => {
+    ++calls.object
+    eventSources.push(eventSource)
+  })
+  observe(arrayRef, (_value, eventSource) => {
+    ++calls.array
+    eventSources.push(eventSource)
+  })
+  observe(setRef, (_value, eventSource) => {
+    ++calls.set
+    eventSources.push(eventSource)
+  })
+  observe(mapKeyRef, (_value, eventSource) => {
+    ++calls.mapKey
+    eventSources.push(eventSource)
+  })
+  observe(mapValueRef, (_value, eventSource) => {
+    ++calls.mapValue
+    eventSources.push(eventSource)
+  })
+
+  const source = { from: 'recursive-trigger' }
+  trigger(root, source, true)
+
+  expect(calls).toStrictEqual({
+    object: 1,
+    // arrays are traversed via both iterable and object-key paths
+    array: 2,
+    set: 1,
+    mapKey: 1,
+    mapValue: 1,
+  })
+  expect(eventSources.every((x) => x === source)).toBe(true)
+})