glre 0.33.0 → 0.34.0

package/src/node/node.ts

@@ -2,13 +2,13 @@ import { is } from '../utils/helpers'
 import { code } from './code'
 import { assign, toVar } from './scope'
 import { conversionToConstant, isConversion, isFunction, isOperator, getId } from './utils'
-import type { Functions, NodeProps, NodeProxy, NodeTypes, Operators, X } from './types'
+import type { Functions, NodeProps, NodeProxy, NodeTypes, Operators, X, Constants as C } from './types'
 
 const toPrimitive = (x: X, hint: string) => {
         if (hint === 'string') return code(x)
 }
 
-export const node = (type: NodeTypes, props?: NodeProps | null, ...args: X[]) => {
+export const node = <T extends C>(type: NodeTypes, props?: NodeProps | null, ...args: X[]) => {
         if (!props) props = {}
         if (args.length) props.children = args
         const listeners = new Set<(value: any) => void>()
@@ -24,28 +24,30 @@ export const node = (type: NodeTypes, props?: NodeProps | null, ...args: X[]) =>
                 if (isOperator(key)) return (...y: X[]) => operator(key, x, ...y)
                 if (isFunction(key)) return (...y: X[]) => function_(key, x, ...y)
                 if (isConversion(key)) return () => conversion(conversionToConstant(key), x)
-                if (is.str(key)) return member(key, x) // for struct
+                if (is.str(key)) return member(key, x) // for struct and swizzling
         }
         const set = (_: unknown, key: string, y: X) => {
                 if (key === 'value') listeners.forEach((fun) => fun(y))
                 if (is.str(key)) member(key, x).assign(y)
                 return true
         }
-        const x = new Proxy({}, { get, set }) as unknown as NodeProxy
+        const x = new Proxy({}, { get, set }) as unknown as NodeProxy<T>
         return x
 }
 
-// headers
-export const attribute = (x: X, id = getId()) => node('attribute', { id }, x)
-export const constant = (x: X, id = getId()) => node('constant', { id }, x)
-export const uniform = (x: X, id = getId()) => node('uniform', { id }, x)
-export const variable = (id = getId()) => node('variable', { id })
-export const builtin = (id = getId()) => node('builtin', { id })
-export const vertexStage = (x: X, id = getId()) => node('varying', { id, inferFrom: [x] }, x)
+// headers with proper type inference
+export const attribute = <T extends C>(x: X, id = getId()) => node<T>('attribute', { id }, x)
+export const constant = <T extends C>(x: X<T>, id = getId()) => node<T>('constant', { id }, x)
+export const uniform = <T extends C>(x: X<T>, id = getId()) => node<T>('uniform', { id }, x)
+export const variable = <T extends C>(id = getId()) => node<T>('variable', { id })
+export const builtin = <T extends C>(id = getId()) => node<T>('builtin', { id })
+export const vertexStage = <T extends C>(x: X<T>, id = getId()) => {
+        return node<T>('varying', { id, inferFrom: [x] }, x)
+}
 
-// Node shorthands
-export const operator = (key: Operators, ...x: X[]) => node('operator', null, key, ...x)
-export const function_ = (key: Functions, ...x: X[]) => node('function', null, key, ...x)
-export const conversion = (key: string, ...x: X[]) => node('conversion', null, key, ...x)
-export const member = (key: string, x: X) => node('member', null, key, x)
-export const select = (x: X, y: X, z: X) => node('ternary', null, x, y, z) // x ? y : z @TODO REMOVE
+// Node shorthands with proper typing
+export const member = <T extends C>(key: string, x: X) => node<T>('member', null, key, x)
+export const select = <T extends C>(x: X<T>, y: X<T>, z: X) => node<T>('ternary', null, x, y, z) // z ? x : y @TODO REMOVE
+export const operator = <T extends C>(key: Operators, ...x: X[]) => node<T>('operator', null, key, ...x)
+export const function_ = <T extends C>(key: Functions, ...x: X[]) => node<T>('function', null, key, ...x)
+export const conversion = <T extends C>(key: T, ...x: X[]) => node<T>('conversion', null, key, ...x)

package/src/node/parse.ts

@@ -1,7 +1,7 @@
 import { is } from '../utils/helpers'
 import { code } from './code'
 import { infer } from './infer'
-import { formatConversions, isConstants, addDependency } from './utils'
+import { formatConversions, addDependency } from './utils'
 import type { Constants, NodeContext, NodeProps, NodeProxy, X } from './types'
 
 export const parseArray = (children: X[], c: NodeContext) => {
@@ -58,7 +58,7 @@ export const parseDeclare = (c: NodeContext, x: X, y: X) => {
         return `var ${varName}: ${wgslType} = ${code(x, c)};`
 }
 
-export const parseDefine = (c: NodeContext, props: NodeProps, returnType: Constants | string) => {
+export const parseDefine = (c: NodeContext, props: NodeProps, returnType: Constants) => {
         const { id, children = [], layout } = props
         const [x, ...args] = children
         const argParams: [name: string, type: string][] = []
@@ -127,7 +127,9 @@ export const parseStruct = (
  * headers
  */
 export const parseVaryingHead = (c: NodeContext, id: string, type: string) => {
-        return c.isWebGL ? `${type} ${id};` : `@location(${c.code?.vertVaryings?.size || 0}) ${id}: ${formatConversions(type, c)}`
+        return c.isWebGL
+                ? `${type} ${id};`
+                : `@location(${c.code?.vertVaryings?.size || 0}) ${id}: ${formatConversions(type, c)}`
 }
 
 export const parseUniformHead = (c: NodeContext, id: string, type: Constants) => {

package/src/node/scope.ts

@@ -1,7 +1,6 @@
-import { int } from '.'
 import { conversion, node } from './node'
 import { getId } from './utils'
-import type { FnLayout, NodeProps, NodeProxy, X } from './types'
+import type { FnLayout, NodeProps, NodeProxy, X, Constants, Int } from './types'
 
 let scope: NodeProxy | null = null
 let define: NodeProxy | null = null
@@ -16,29 +15,28 @@ const addToScope = (x: NodeProxy) => {
         props.inferFrom.push(x)
 }
 
-export const toVar = (x: X, id?: string) => {
+export const toVar = <T extends Constants>(x: X<T>, id?: string): NodeProxy<T> => {
         if (!id) id = getId()
-        const y = node('variable', { id, inferFrom: [x] })
+        const y = node<T>('variable', { id, inferFrom: [x] })
         const z = node('declare', null, x, y)
         addToScope(z)
         return y
 }
 
-export const assign = (x: X, y: X) => {
+export const assign = <T extends Constants>(x: X<T>, y: X<T>): X<T> => {
         const z = node('assign', null, x, y)
         addToScope(z)
         return x
 }
 
-export const Return = (x: X) => {
-        const y = node('return', { inferFrom: [x] }, x)
+export const Return = <T extends Constants>(x: X<T>): NodeProxy<T> => {
+        const y = node<T>('return', { inferFrom: [x] }, x)
         addToScope(y)
         return y
 }
 
-// Struct functions
-export const struct = (fields: Record<string, NodeProxy>, id = getId()) => {
-        return (initialValues: Record<string, NodeProxy> = {}, instanceId = getId()) => {
+export const struct = <T extends Record<string, NodeProxy>>(fields: T, id = getId()) => {
+        return (initialValues: T = {} as T, instanceId = getId()) => {
                 const x = node('variable', { id: instanceId, inferFrom: [id] })
                 const y = node('struct', { id, fields, initialValues }, x)
                 addToScope(y)
@@ -61,7 +59,7 @@ const scoped = (x: NodeProxy, fun: () => NodeProxy | void, y = define) => {
         define = _define
 }
 
-export const If = (x: X, fun: () => void) => {
+export const If = (x: NodeProxy, fun: () => void) => {
         const y = node('scope')
         scoped(y, fun)
         const ifNode = node('if', null, x, y)
@@ -82,15 +80,15 @@ export const If = (x: X, fun: () => void) => {
         return ret()
 }
 
-export const Loop = (x: X, fun: (params: { i: NodeProxy }) => void) => {
+export const Loop = (x: NodeProxy, fun: (params: { i: Int }) => void) => {
         const y = node('scope')
-        scoped(y, () => fun({ i: node('variable', { id: 'i', inferFrom: [int(0)] }) }))
+        scoped(y, () => fun({ i: node<'int'>('variable', { id: 'i', inferFrom: [conversion('int', 0)] }) }))
         const ret = node('loop', null, x, y)
         addToScope(ret)
         return ret
 }
 
-export const Switch = (x: X) => {
+export const Switch = (x: NodeProxy) => {
         const switchNode = node('switch', null, x)
         addToScope(switchNode)
         const ret = () => ({
@@ -111,10 +109,13 @@ export const Switch = (x: X) => {
         return ret()
 }
 
-export const Fn = (fun: (paramVars: NodeProxy[]) => NodeProxy) => {
+export const Fn = <ReturnType extends Constants, Args extends Constants[]>(
+        fun: (paramVars: NodeProxy[]) => NodeProxy<ReturnType> | void,
+        defaultId = getId()
+) => {
         let layout: FnLayout
-        const ret = (...args: X[]) => {
-                const id = layout?.name || getId()
+        const ret = (...args: X<Args[number]>[]): NodeProxy<ReturnType> => {
+                const id = layout?.name || defaultId
                 const x = node('scope')
                 const paramVars: NodeProxy[] = []
                 const paramDefs: NodeProps[] = []
@@ -127,10 +128,13 @@ export const Fn = (fun: (paramVars: NodeProxy[]) => NodeProxy) => {
                                 paramDefs.push({ id: `p${i}`, inferFrom: [args[i]] })
                         }
                 for (const props of paramDefs) paramVars.push(node('variable', props))
-                const y = node('define', { id, layout }, x, ...args)
+                const y = node<ReturnType>('define', { id, layout }, x, ...args)
                 scoped(x, () => fun(paramVars), y)
                 return y
         }
-        ret.setLayout = (_layout: FnLayout) => void (layout = _layout)
+        ret.setLayout = (_layout: FnLayout) => {
+                layout = _layout
+                return ret
+        }
         return ret
 }

package/src/node/types.ts

@@ -1,4 +1,5 @@
 import { GL } from '../types'
+
 import { CONSTANTS, CONVERSIONS, FUNCTIONS, OPERATOR_KEYS } from './const'
 
 export type Constants = (typeof CONSTANTS)[number] | 'void'
@@ -47,17 +48,17 @@ export type NodeTypes =
         | 'declare'
         | 'return'
 
-export interface NodeProps {
+export interface NodeProps<T extends Record<string, NodeProxy> = {}> {
         id?: string
-        args?: X[]
+        args?: any[]
         type?: string
-        children?: X[]
-        inferFrom?: X[]
+        children?: any[]
+        inferFrom?: any[]
         layout?: FnLayout
         parent?: NodeProxy
         // for struct
-        fields?: Record<string, NodeProxy>
-        initialValues?: Record<string, NodeProxy>
+        fields?: T
+        initialValues?: T
 }
 
 export interface NodeContext {
@@ -78,7 +79,48 @@ export interface NodeContext {
 }
 
 /**
- * NodeProxy
+ * infer
+ */
+// Unified logic with infer.ts inferOperator function
+// prettier-ignore
+type InferOperator<L extends Constants, R extends Constants> =
+        L extends R ? L :
+        // broadcast
+        L extends 'float' | 'int' ? R :
+        R extends 'float' | 'int' ? L :
+        // mat * vec → vec
+        L extends 'mat4' ? R extends 'vec4' ? R /* default */ : L :
+        L extends 'mat3' ? R extends 'vec3' ? R /* default */ : L :
+        L extends 'mat2' ? R extends 'vec2' ? R /* default */ : L :
+        // vec * mat → vec
+        L extends 'vec4' ? R extends 'mat4' ? L /* default */ : L :
+        L extends 'vec3' ? R extends 'mat3' ? L /* default */ : L :
+        L extends 'vec2' ? R extends 'mat2' ? L /* default */ : L : L
+
+type _StringLength<S extends string> = S extends `${infer _}${infer Rest}`
+        ? Rest extends ''
+                ? 1
+                : Rest extends `${infer _}${infer Rest2}`
+                ? Rest2 extends ''
+                        ? 2
+                        : Rest2 extends `${infer _}${infer Rest3}`
+                        ? Rest3 extends ''
+                                ? 3
+                                : 4
+                        : never
+                : never
+        : 0
+
+type InferSwizzleType<S extends string> = _StringLength<S> extends 4
+        ? 'vec4'
+        : _StringLength<S> extends 3
+        ? 'vec3'
+        : _StringLength<S> extends 2
+        ? 'vec2'
+        : 'float'
+
+/**
+ * Swizzles
  */
 type _Swizzles<T extends string> = T | `${T}${T}` | `${T}${T}${T}` | `${T}${T}${T}${T}`
 
@@ -101,14 +143,10 @@ type NodeProxyMethods =
         | 'toVar'
         | 'toString'
 
-export type ReadNodeProxy = {
-        [K in string as K extends NodeProxyMethods ? never : K]: X
-}
-
-export interface BaseNodeProxy extends Record<Swizzles, NodeProxy> {
+export interface BaseNodeProxy<T extends Constants> {
         // System properties
-        assign(n: X): NodeProxy
-        toVar(name?: string): NodeProxy
+        assign(x: any): NodeProxy<T>
+        toVar(name?: string): NodeProxy<T>
         toString(c?: NodeContext): string
         type: NodeTypes
         props: NodeProps
@@ -116,90 +154,176 @@ export interface BaseNodeProxy extends Record<Swizzles, NodeProxy> {
         listeners: Set<(value: any) => void>
 
         // Operators methods
-        add(n: X): NodeProxy
-        sub(n: X): NodeProxy
-        mul(n: X): NodeProxy
-        div(n: X): NodeProxy
-        mod(n: X): NodeProxy
-        equal(n: X): NodeProxy
-        notEqual(n: X): NodeProxy
-        lessThan(n: X): NodeProxy
-        lessThanEqual(n: X): NodeProxy
-        greaterThan(n: X): NodeProxy
-        greaterThanEqual(n: X): NodeProxy
-        and(n: X): NodeProxy
-        or(n: X): NodeProxy
-        not(): NodeProxy
-
-        // Conversations methods
-        toBool(): NodeProxy
-        toUint(): NodeProxy
-        toInt(): NodeProxy
-        toFloat(): NodeProxy
-        toBvec2(): NodeProxy
-        toIvec2(): NodeProxy
-        toUvec2(): NodeProxy
-        toVec2(): NodeProxy
-        toBvec3(): NodeProxy
-        toIvec3(): NodeProxy
-        toUvec3(): NodeProxy
-        toVec3(): NodeProxy
-        toBvec4(): NodeProxy
-        toIvec4(): NodeProxy
-        toUvec4(): NodeProxy
-        toVec4(): NodeProxy
-        toColor(): NodeProxy
-        toMat2(): NodeProxy
-        toMat3(): NodeProxy
-        toMat4(): NodeProxy
-
-        // Function methods
-        abs(): NodeProxy
-        sin(): NodeProxy
-        cos(): NodeProxy
-        tan(): NodeProxy
-        asin(): NodeProxy
-        acos(): NodeProxy
-        atan(): NodeProxy
-        atan2(x: X): NodeProxy
-        pow(y: X): NodeProxy
-        pow2(): NodeProxy
-        pow3(): NodeProxy
-        pow4(): NodeProxy
-        sqrt(): NodeProxy
-        inverseSqrt(): NodeProxy
-        exp(): NodeProxy
-        exp2(): NodeProxy
-        log(): NodeProxy
-        log2(): NodeProxy
-        floor(): NodeProxy
-        ceil(): NodeProxy
-        round(): NodeProxy
-        fract(): NodeProxy
-        trunc(): NodeProxy
-        min(y: X): NodeProxy
-        max(y: X): NodeProxy
-        clamp(min: X, max: X): NodeProxy
-        saturate(): NodeProxy
-        mix(y: X, a: X): NodeProxy
-        step(edge: X): NodeProxy
-        smoothstep(edge0: X, edge1: X): NodeProxy
-        length(): NodeProxy
-        distance(y: X): NodeProxy
-        dot(y: X): NodeProxy
-        cross(y: X): NodeProxy
-        normalize(): NodeProxy
-        reflect(N: X): NodeProxy
-        refract(N: X, eta: X): NodeProxy
-        sign(): NodeProxy
-        oneMinus(): NodeProxy
-        reciprocal(): NodeProxy
-        negate(): NodeProxy
-        dFdx(): NodeProxy
-        dFdy(): NodeProxy
-        fwidth(): NodeProxy
+        add<U extends Constants>(x: X<U>): NodeProxy<InferOperator<T, U>>
+        sub<U extends Constants>(x: X<U>): NodeProxy<InferOperator<T, U>>
+        mul<U extends Constants>(x: X<U>): NodeProxy<InferOperator<T, U>>
+        div<U extends Constants>(x: X<U>): NodeProxy<InferOperator<T, U>>
+        mod<U extends Constants>(x: X<U>): NodeProxy<InferOperator<T, U>>
+        equal<U extends Constants>(x: X<U>): Bool
+        notEqual<U extends Constants>(x: X<U>): Bool
+        lessThan<U extends Constants>(x: X<U>): Bool
+        lessThanEqual<U extends Constants>(x: X<U>): Bool
+        greaterThan<U extends Constants>(x: X<U>): Bool
+        greaterThanEqual<U extends Constants>(x: X<U>): Bool
+        and(x: X<'bool'>): Bool
+        or(x: X<'bool'>): Bool
+        not(): Bool
+
+        // Bitwise operators
+        bitAnd(x: X<T>): NodeProxy<T>
+        bitOr(x: X<T>): NodeProxy<T>
+        bitXor(x: X<T>): NodeProxy<T>
+        bitNot(): NodeProxy<T>
+        shiftLeft<U extends Constants>(x: X<U>): NodeProxy<InferOperator<T, U>>
+        shiftRight<U extends Constants>(x: X<U>): NodeProxy<InferOperator<T, U>>
+
+        // Conversion methods
+        toBool(): Bool
+        toUint(): UInt
+        toInt(): Int
+        toFloat(): Float
+        toBvec2(): BVec2
+        toIvec2(): IVec2
+        toUvec2(): UVec2
+        toVec2(): Vec2
+        toBvec3(): BVec3
+        toIvec3(): IVec3
+        toUvec3(): UVec3
+        toVec3(): Vec3
+        toBvec4(): BVec4
+        toIvec4(): IVec4
+        toUvec4(): UVec4
+        toVec4(): Vec4
+        toColor(): Color
+        toMat2(): Mat2
+        toMat3(): Mat3
+        toMat4(): Mat4
+
+        // Mathematical function methods (preserve type functions)
+        abs(): NodeProxy<T>
+        sign(): NodeProxy<T>
+        floor(): NodeProxy<T>
+        ceil(): NodeProxy<T>
+        round(): NodeProxy<T>
+        fract(): NodeProxy<T>
+        trunc(): NodeProxy<T>
+        sin(): NodeProxy<T>
+        cos(): NodeProxy<T>
+        tan(): NodeProxy<T>
+        asin(): NodeProxy<T>
+        acos(): NodeProxy<T>
+        atan(): NodeProxy<T>
+        exp(): NodeProxy<T>
+        exp2(): NodeProxy<T>
+        log(): NodeProxy<T>
+        log2(): NodeProxy<T>
+        sqrt(): NodeProxy<T>
+        inverseSqrt(): NodeProxy<T>
+        normalize(): NodeProxy<T>
+        oneMinus(): NodeProxy<T>
+        saturate(): NodeProxy<T>
+        negate(): NodeProxy<T>
+        reciprocal(): NodeProxy<T>
+        dFdx(): NodeProxy<T>
+        dFdy(): NodeProxy<T>
+        fwidth(): NodeProxy<T>
+
+        // Scalar return functions
+        length(): Float
+        lengthSq(): Float
+        determinant(): Float
+        luminance(): Float
+
+        // Bool return functions
+        all(): Bool
+        any(): Bool
+
+        // Specific return type functions
+        cross<U extends Constants>(y: X<U>): Vec3
+
+        // Two argument functions with variable return types
+        atan2<U extends Constants>(x: X<U>): NodeProxy<T>
+        pow<U extends Constants>(y: X<U>): NodeProxy<T>
+        distance<U extends Constants>(y: X<U>): Float
+        dot<U extends Constants>(y: X<U>): Float
+        reflect<U extends Constants>(N: X<U>): NodeProxy<T>
+        refract<U extends Constants>(N: X<U>, eta: any): NodeProxy<T>
+
+        // Multi-argument functions that return highest priority type
+        min<U extends Constants>(y: X<U>): NodeProxy<InferOperator<T, U>>
+        max<U extends Constants>(y: X<U>): NodeProxy<InferOperator<T, U>>
+        mix<U extends Constants, V>(y: X<U>, a: V): NodeProxy<InferOperator<T, U>>
+        clamp<U extends Constants, V>(mix: X<U>, max: V): NodeProxy<InferOperator<T, U>>
+        step<U extends Constants>(edge: X<U>): NodeProxy<InferOperator<T, U>>
+        smoothstep<U extends Constants, V>(edge0: X<U>, edge1: V): NodeProxy<InferOperator<T, U>>
+
+        // Power functions
+        pow2(): NodeProxy<T>
+        pow3(): NodeProxy<T>
+        pow4(): NodeProxy<T>
+}
+
+type ReadNodeProxy = {
+        [K in string as K extends NodeProxyMethods ? never : K]: any
+} & {
+        [K in Swizzles]: NodeProxy<InferSwizzleType<K>>
+}
+
+// Internal NodeProxy implementation (renamed from original)
+type NodeProxyImpl<T extends Constants = string> = BaseNodeProxy<T> & ReadNodeProxy
+
+export type Bool = NodeProxyImpl<'bool'>
+export type UInt = NodeProxyImpl<'uint'>
+export type Int = NodeProxyImpl<'int'>
+export type Float = NodeProxyImpl<'float'>
+export type BVec2 = NodeProxyImpl<'bvec2'>
+export type IVec2 = NodeProxyImpl<'ivec2'>
+export type UVec2 = NodeProxyImpl<'uvec2'>
+export type Vec2 = NodeProxyImpl<'vec2'>
+export type BVec3 = NodeProxyImpl<'bvec3'>
+export type IVec3 = NodeProxyImpl<'ivec3'>
+export type UVec3 = NodeProxyImpl<'uvec3'>
+export type Vec3 = NodeProxyImpl<'vec3'>
+export type BVec4 = NodeProxyImpl<'bvec4'>
+export type IVec4 = NodeProxyImpl<'ivec4'>
+export type UVec4 = NodeProxyImpl<'uvec4'>
+export type Vec4 = NodeProxyImpl<'vec4'>
+export type Color = NodeProxyImpl<'color'>
+export type Mat2 = NodeProxyImpl<'mat2'>
+export type Mat3 = NodeProxyImpl<'mat3'>
+export type Mat4 = NodeProxyImpl<'mat4'>
+export type Texture = NodeProxyImpl<'texture'>
+export type Sampler2D = NodeProxyImpl<'sampler2D'>
+export type Struct = NodeProxyImpl<'struct'>
+
+export interface ConstantsToType {
+        bool: Bool
+        uint: UInt
+        int: Int
+        float: Float
+        bvec2: BVec2
+        ivec2: IVec2
+        uvec2: UVec2
+        vec2: Vec2
+        bvec3: BVec3
+        ivec3: IVec3
+        uvec3: UVec3
+        vec3: Vec3
+        bvec4: BVec4
+        ivec4: IVec4
+        uvec4: UVec4
+        vec4: Vec4
+        color: Color
+        mat2: Mat2
+        mat3: Mat3
+        mat4: Mat4
+        texture: Texture
+        sampler2D: Sampler2D
+        struct: Struct
 }
 
-export type NodeProxy = BaseNodeProxy & ReadNodeProxy
+export type NodeProxy<T extends Constants = string> = T extends keyof ConstantsToType
+        ? ConstantsToType[T]
+        : NodeProxyImpl<T>
 
-export type X = X[] | (NodeProxy | number | string | boolean | undefined)
+export type X<T extends Constants = string> = number | string | boolean | undefined | NodeProxy<T> | X[]

package/src/node/utils.ts

@@ -26,7 +26,7 @@ export const isConversion = (key: unknown): key is Conversions => {
         return CONVERSIONS.includes(key as Conversions)
 }
 
-export const isNodeProxy = (x: unknown): x is NodeProxy => {
+export const isNodeProxy = <T extends Constants>(x: unknown): x is NodeProxy<T> => {
         if (!x) return false
         if (typeof x !== 'object') return false // @ts-ignore
         return x.isProxy
@@ -48,13 +48,13 @@ let count = 0
 
 export const getId = () => `i${count++}`
 
-export const formatConversions = (x: X, c?: NodeContext) => {
+export const formatConversions = <T extends Constants>(x: X<T>, c?: NodeContext) => {
         if (!is.str(x)) return ''
         if (c?.isWebGL) return x
         return TYPE_MAPPING[x as keyof typeof TYPE_MAPPING] || x // for struct type
 }
 
-export const getOperator = (op: X) => {
+export const getOperator = (op: X<string>) => {
         return OPERATORS[op as keyof typeof OPERATORS] || op
 }
 
@@ -78,7 +78,7 @@ export const getEventFun = (c: NodeContext, id: string, isAttribute = false, isT
         return (value: any) => c.gl?._uniform?.(id, value)
 }
 
-export const safeEventCall = (x: X, fun: (value: unknown) => void) => {
+export const safeEventCall = <T extends Constants>(x: X<T>, fun: (value: unknown) => void) => {
         if (!x) return
         if (!isNodeProxy(x)) return fun(x) // for uniform(1)
         if (x.type !== 'conversion') return

package/src/types.ts

@@ -1,6 +1,6 @@
 import type { EventState, Nested } from 'reev'
 import type { Fun, Queue, Frame } from 'refr'
-import type { NodeProxy } from './node'
+import type { NodeProxy, Vec4 } from './node'
 export type { Fun, Queue, Frame }
 export type PrecisionMode = 'highp' | 'mediump' | 'lowp'
 export type GLClearMode = 'COLOR_BUFFER_BIT' | 'DEPTH_BUFFER_BIT' | 'STENCIL_BUFFER_BIT'
@@ -67,12 +67,12 @@ export type GL = EventState<{
         mouse: [number, number]
         count: number
         el: HTMLCanvasElement
-        vs: string | NodeProxy
-        fs: string | NodeProxy
-        vert: string | NodeProxy
-        frag: string | NodeProxy
-        vertex: string | NodeProxy
-        fragment: string | NodeProxy
+        vs: string | Vec4
+        fs: string | Vec4
+        vert: string | Vec4
+        frag: string | Vec4
+        vertex: string | Vec4
+        fragment: string | Vec4
 
         /**
          * core state