glre 0.32.0 → 0.34.0

package/src/node/index.ts

@@ -1,8 +1,8 @@
 import { is } from '../utils/helpers'
 import { code } from './code'
 import { builtin, conversion as c, function_ as f, uniform as u } from './node'
-import { hex2rgb } from './utils'
-import type { NodeContext, X } from './types'
+import { hex2rgb, sortHeadersByDependencies } from './utils'
+import type { Constants as C, NodeContext, X, Vec2, Float } from './types'
 export * from './code'
 export * from './node'
 export * from './scope'
@@ -17,7 +17,11 @@ out vec4 fragColor;
 
 const generateHead = (x: X, c: NodeContext) => {
         const body = code(x, c)
-        const head = Array.from(c.headers!.values()).join('\n')
+        let head = ''
+        if (c.isWebGL && c.code?.dependencies) {
+                const sorted = sortHeadersByDependencies(c.code.headers, c.code.dependencies)
+                head = sorted.map(([, value]) => value).join('\n')
+        } else head = Array.from(c.code?.headers?.values() || []).join('\n')
         return [head, body]
 }
 
@@ -26,82 +30,84 @@ const generateStruct = (id: string, map: Map<string, string>) => {
 }
 
 export const vertex = (x: X, c: NodeContext) => {
-        c.headers?.clear()
+        if (is.str(x)) return x.trim()
+        c.code?.headers?.clear()
         c.isFrag = false // for varying inputs or outputs
         const [head, body] = generateHead(x, c)
         const ret = []
         if (c.isWebGL) {
                 ret.push('#version 300 es')
-                for (const code of c.vertInputs!.values()) ret.push(`in ${code}`)
-                for (const code of c.vertOutputs!.values()) ret.push(`out ${code}`)
+                for (const code of c.code?.vertInputs?.values() || []) ret.push(`in ${code}`)
+                for (const code of c.code?.vertOutputs?.values() || []) ret.push(`out ${code}`)
                 ret.push(head)
                 ret.push('void main() {')
                 ret.push(`  gl_Position = ${body};`)
-                for (const [id, code] of c.vertVaryings!.entries()) ret.push(`  ${id} = ${code};`)
+                for (const [id, code] of c.code?.vertVaryings?.entries() || []) ret.push(`  ${id} = ${code};`)
         } else {
-                if (c.vertInputs?.size) ret.push(generateStruct('In', c.vertInputs))
-                if (c.vertOutputs?.size) ret.push(generateStruct('Out', c.vertOutputs))
+                if (c.code?.vertInputs?.size) ret.push(generateStruct('In', c.code.vertInputs))
+                if (c.code?.vertOutputs?.size) ret.push(generateStruct('Out', c.code.vertOutputs))
                 ret.push(head)
                 ret.push('@vertex')
-                ret.push(`fn main(${c.vertInputs?.size ? 'in: In' : ''}) -> Out {`)
+                ret.push(`fn main(${c.code?.vertInputs?.size ? 'in: In' : ''}) -> Out {`)
                 ret.push('  var out: Out;')
                 ret.push(`  out.position = ${body};`)
-                for (const [id, code] of c.vertVaryings!.entries()) ret.push(`  out.${id} = ${code};`)
+                for (const [id, code] of c.code?.vertVaryings?.entries() || []) ret.push(`  out.${id} = ${code};`)
                 ret.push('  return out;')
         }
         ret.push('}')
-        const main = ret.filter(Boolean).join('\n')
+        const main = ret.filter(Boolean).join('\n').trim()
         console.log(`↓↓↓generated↓↓↓\n${main}`)
         return main
 }
 
 export const fragment = (x: X, c: NodeContext) => {
-        c.headers?.clear()
+        if (is.str(x)) return x.trim()
+        c.code?.headers?.clear()
         c.isFrag = true // for varying inputs or outputs
         const [head, body] = generateHead(x, c)
         const ret = []
         if (c.isWebGL) {
                 ret.push(GLSL_FRAGMENT_HEAD)
-                for (const code of c.fragInputs!.values()) ret.push(`in ${code}`)
+                for (const code of c.code?.fragInputs?.values() || []) ret.push(`in ${code}`)
                 ret.push(head)
                 ret.push(`void main() {\n  fragColor = ${body};`)
         } else {
-                if (c.fragInputs?.size) ret.push(generateStruct('Out', c.fragInputs))
+                if (c.code?.fragInputs?.size) ret.push(generateStruct('Out', c.code.fragInputs))
                 ret.push(head)
                 ret.push(`@fragment\nfn main(out: Out) -> @location(0) vec4f {`)
                 ret.push(`  return ${body};`)
         }
         ret.push('}')
-        const main = ret.filter(Boolean).join('\n')
+        const main = ret.filter(Boolean).join('\n').trim()
         console.log(`↓↓↓generated↓↓↓\n${main}`)
         return main
 }
 
 // Builtin Variables
-export const position = builtin('position')
-export const vertexIndex = builtin('vertex_index')
-export const instanceIndex = builtin('instance_index')
-export const frontFacing = builtin('front_facing')
-export const fragDepth = builtin('frag_depth')
-export const sampleIndex = builtin('sample_index')
-export const sampleMask = builtin('sample_mask')
-export const pointCoord = builtin('point_coord')
+export const position = builtin<'vec4'>('position')
+export const vertexIndex = builtin<'uint'>('vertex_index')
+export const instanceIndex = builtin<'uint'>('instance_index')
+export const frontFacing = builtin<'bool'>('front_facing')
+export const fragDepth = builtin<'float'>('frag_depth')
+export const sampleIndex = builtin<'uint'>('sample_index')
+export const sampleMask = builtin<'uint'>('sample_mask')
+export const pointCoord = builtin<'vec2'>('point_coord')
 
 // TSL Compatible Builtin Variables
-export const normalLocal = builtin('normalLocal')
-export const normalWorld = builtin('normalWorld')
-export const normalView = builtin('normalView')
-export const positionLocal = builtin('position')
-export const positionWorld = builtin('positionWorld')
-export const positionView = builtin('positionView')
-export const screenCoordinate = builtin('screenCoordinate')
-export const screenUV = builtin('screenUV')
-
-// Type constructors
-export const float = (x: X) => c('float', x)
-export const int = (x: X) => c('int', x)
-export const uint = (x: X) => c('uint', x)
-export const bool = (x: X) => c('bool', x)
+export const positionLocal = builtin<'vec3'>('position')
+export const positionWorld = builtin<'vec3'>('positionWorld')
+export const positionView = builtin<'vec3'>('positionView')
+export const normalLocal = builtin<'vec3'>('normalLocal')
+export const normalWorld = builtin<'vec3'>('normalWorld')
+export const normalView = builtin<'vec3'>('normalView')
+export const screenCoordinate = builtin<'vec2'>('screenCoordinate')
+export const screenUV = builtin<'vec2'>('screenUV')
+
+// Type constructors with proper type inference
+export const float = (x?: X) => c('float', x)
+export const int = (x?: X) => c('int', x)
+export const uint = (x?: X) => c('uint', x)
+export const bool = (x?: X) => c('bool', x)
 export const vec2 = (x?: X, y?: X) => c('vec2', x, y)
 export const vec3 = (x?: X, y?: X, z?: X) => c('vec3', x, y, z)
 export const vec4 = (x?: X, y?: X, z?: X, w?: X) => c('vec4', x, y, z, w)
@@ -117,77 +123,99 @@ export const uvec4 = (x?: X, y?: X, z?: X, w?: X) => c('uvec4', x, y, z, w)
 export const bvec2 = (x?: X, y?: X) => c('bvec2', x, y)
 export const bvec3 = (x?: X, y?: X, z?: X) => c('bvec3', x, y, z)
 export const bvec4 = (x?: X, y?: X, z?: X, w?: X) => c('bvec4', x, y, z, w)
-export const texture2D = () => c('texture')
+export const texture2D = (x?: X) => c('texture', x)
 export const sampler2D = () => c('sampler2D')
 export const color = (r?: X, g?: X, b?: X) => {
         if (is.num(r) && is.und(g) && is.und(b)) return vec3(...hex2rgb(r))
         return vec3(r, g, b)
 }
 
-// Default uniforms
-export const iResolution = u(vec2(1280, 800), 'iResolution')
-export const iMouse = u(vec2(0, 0), 'iMouse')
-export const iTime = u(float(0), 'iTime')
-export const uv = () => position.xy.div(iResolution)
-
-// Texture Functions
-export const texture = (x: X, y: X, z?: X) => f('texture', x, y, z)
-export const cubeTexture = (x: X, y: X, z?: X) => f('cubeTexture', x, y, z)
-export const textureSize = (x: X, y?: X) => f('textureSize', x, y)
-
-// Math Functions
-export const abs = (x: X) => f('abs', x)
-export const acos = (x: X) => f('acos', x)
-export const all = (x: X) => f('all', x)
-export const any = (x: X) => f('any', x)
-export const asin = (x: X) => f('asin', x)
-export const atan = (y: X, x?: X) => (x !== undefined ? f('atan', y, x) : f('atan', y))
-export const atan2 = (y: X, x: X) => f('atan', y, x)
-export const bitcast = (x: X, y: X) => f('bitcast', x, y)
-export const cbrt = (x: X) => f('cbrt', x)
-export const ceil = (x: X) => f('ceil', x)
-export const clamp = (x: X, min: X, max: X) => f('clamp', x, min, max)
-export const cos = (x: X) => f('cos', x)
-export const cross = (x: X, y: X) => f('cross', x, y)
-export const dFdx = (p: X) => f('dFdx', p)
-export const dFdy = (p: X) => f('dFdy', p)
-export const degrees = (radians: X) => f('degrees', radians)
-export const difference = (x: X, y: X) => f('difference', x, y)
-export const distance = (x: X, y: X) => f('distance', x, y)
-export const dot = (x: X, y: X) => f('dot', x, y)
-export const equals = (x: X, y: X) => f('equals', x, y)
-export const exp = (x: X) => f('exp', x)
-export const exp2 = (x: X) => f('exp2', x)
-export const faceforward = (N: X, I: X, Nref: X) => f('faceforward', N, I, Nref)
-export const floor = (x: X) => f('floor', x)
-export const fract = (x: X) => f('fract', x)
-export const fwidth = (x: X) => f('fwidth', x)
-export const inverseSqrt = (x: X) => f('inverseSqrt', x)
-export const length = (x: X) => f('length', x)
-export const lengthSq = (x: X) => f('lengthSq', x)
-export const log = (x: X) => f('log', x)
-export const log2 = (x: X) => f('log2', x)
-export const max = (x: X, y: X) => f('max', x, y)
-export const min = (x: X, y: X) => f('min', x, y)
-export const mix = (x: X, y: X, a: X) => f('mix', x, y, a)
-export const negate = (x: X) => f('negate', x)
-export const normalize = (x: X) => f('normalize', x)
-export const oneMinus = (x: X) => f('oneMinus', x)
-export const pow = (x: X, y: X) => f('pow', x, y)
-export const pow2 = (x: X) => f('pow2', x)
-export const pow3 = (x: X) => f('pow3', x)
-export const pow4 = (x: X) => f('pow4', x)
-export const radians = (degrees: X) => f('radians', degrees)
-export const reciprocal = (x: X) => f('reciprocal', x)
-export const reflect = (I: X, N: X) => f('reflect', I, N)
-export const refract = (I: X, N: X, eta: X) => f('refract', I, N, eta)
-export const round = (x: X) => f('round', x)
-export const saturate = (x: X) => f('saturate', x)
-export const sign = (x: X) => f('sign', x)
-export const sin = (x: X) => f('sin', x)
-export const smoothstep = (e0: X, e1: X, x: X) => f('smoothstep', e0, e1, x)
-export const sqrt = (x: X) => f('sqrt', x)
-export const step = (edge: X, x: X) => f('step', edge, x)
-export const tan = (x: X) => f('tan', x)
-export const transformDirection = (dir: X, matrix: X) => f('transformDirection', dir, matrix)
-export const trunc = (x: X) => f('trunc', x)
+// Default uniforms with proper typing
+export const iResolution: Vec2 = u(vec2(), 'iResolution')
+export const iMouse: Vec2 = u(vec2(), 'iMouse')
+export const iTime: Float = u(float(), 'iTime')
+export const uv = position.xy.div(iResolution)
+
+// Texture Functions - always return vec4
+export const texture = (x: X, y: X, z?: X) => f<'vec4'>('texture', x, y, z)
+export const cubeTexture = (x: X, y: X, z?: X) => f<'vec4'>('cubeTexture', x, y, z)
+export const textureSize = (x: X, y?: X) => f<'vec4'>('textureSize', x, y)
+
+// Functions that always return float regardless of input
+export const length = (x: X) => f<'float'>('length', x)
+export const lengthSq = (x: X) => f<'float'>('lengthSq', x)
+export const distance = (x: X, y: X) => f<'float'>('distance', x, y)
+export const dot = (x: X, y: X) => f<'float'>('dot', x, y)
+
+// Functions that always return bool
+export const all = <T extends C>(x: X<T>) => f<'bool'>('all', x)
+export const any = <T extends C>(x: X<T>) => f<'bool'>('any', x)
+
+// Functions that always return vec3 (cross product only works with vec3)
+export const cross = (x: X<'vec3'>, y: X<'vec3'>) => f<'vec3'>('cross', x, y)
+
+// Component-wise functions - preserve input type (T -> T)
+export const abs = <T extends C>(x: X<T>) => f<T>('abs', x)
+export const sign = <T extends C>(x: X<T>) => f<T>('sign', x)
+export const floor = <T extends C>(x: X<T>) => f<T>('floor', x)
+export const ceil = <T extends C>(x: X<T>) => f<T>('ceil', x)
+export const round = <T extends C>(x: X<T>) => f<T>('round', x)
+export const fract = <T extends C>(x: X<T>) => f<T>('fract', x)
+export const trunc = <T extends C>(x: X<T>) => f<T>('trunc', x)
+export const sin = <T extends C>(x: X<T>) => f<T>('sin', x)
+export const cos = <T extends C>(x: X<T>) => f<T>('cos', x)
+export const tan = <T extends C>(x: X<T>) => f<T>('tan', x)
+export const asin = <T extends C>(x: X<T>) => f<T>('asin', x)
+export const acos = <T extends C>(x: X<T>) => f<T>('acos', x)
+export const atan = <T extends C>(x: X<T>) => f<T>('atan', x)
+export const sinh = <T extends C>(x: X<T>) => f<T>('sinh', x)
+export const cosh = <T extends C>(x: X<T>) => f<T>('cosh', x)
+export const tanh = <T extends C>(x: X<T>) => f<T>('tanh', x)
+export const asinh = <T extends C>(x: X<T>) => f<T>('asinh', x)
+export const acosh = <T extends C>(x: X<T>) => f<T>('acosh', x)
+export const atanh = <T extends C>(x: X<T>) => f<T>('atanh', x)
+export const exp = <T extends C>(x: X<T>) => f<T>('exp', x)
+export const exp2 = <T extends C>(x: X<T>) => f<T>('exp2', x)
+export const log = <T extends C>(x: X<T>) => f<T>('log', x)
+export const log2 = <T extends C>(x: X<T>) => f<T>('log2', x)
+export const sqrt = <T extends C>(x: X<T>) => f<T>('sqrt', x)
+export const inverseSqrt = <T extends C>(x: X<T>) => f<T>('inverseSqrt', x)
+export const normalize = <T extends C>(x: X<T>) => f<T>('normalize', x)
+export const oneMinus = <T extends C>(x: X<T>) => f<T>('oneMinus', x)
+export const saturate = <T extends C>(x: X<T>) => f<T>('saturate', x)
+export const negate = <T extends C>(x: X<T>) => f<T>('negate', x)
+export const reciprocal = <T extends C>(x: X<T>) => f<T>('reciprocal', x)
+export const dFdx = <T extends C>(x: X<T>) => f<T>('dFdx', x)
+export const dFdy = <T extends C>(x: X<T>) => f<T>('dFdy', x)
+export const fwidth = <T extends C>(x: X<T>) => f<T>('fwidth', x)
+export const degrees = <T extends C>(x: X<T>) => f<T>('degrees', x)
+export const radians = <T extends C>(x: X<T>) => f<T>('radians', x)
+
+// Functions where first argument determines return type
+export const reflect = <T extends C>(I: X<T>, N: X) => f<T>('reflect', I, N)
+export const refract = <T extends C>(I: X<T>, N: X, eta: X) => f<T>('refract', I, N, eta)
+
+// Functions with highest priority type among arguments (using first arg for simplicity)
+export const min = <T extends C>(x: X<T>, y: X) => f<T>('min', x, y)
+export const max = <T extends C>(x: X<T>, y: X) => f<T>('max', x, y)
+export const mix = <T extends C>(x: X<T>, y: X, a: X) => f<T>('mix', x, y, a)
+export const clamp = <T extends C>(x: X<T>, minVal: X, maxVal: X) => f<T>('clamp', x, minVal, maxVal)
+export const step = <T extends C>(edge: X, x: X<T>) => f<T>('step', edge, x)
+export const smoothstep = <T extends C>(e0: X, e1: X, x: X<T>) => f<T>('smoothstep', e0, e1, x)
+
+// Two-argument functions with highest priority type
+export const atan2 = <T extends C>(y: X<T>, x: X) => f<T>('atan2', y, x)
+export const pow = <T extends C>(x: X<T>, y: X) => f<T>('pow', x, y)
+
+// Component-wise power functions
+export const pow2 = <T extends C>(x: X<T>) => f<T>('pow2', x)
+export const pow3 = <T extends C>(x: X<T>) => f<T>('pow3', x)
+export const pow4 = <T extends C>(x: X<T>) => f<T>('pow4', x)
+
+// Utility functions
+export const bitcast = <T extends C>(x: X<T>, y: X) => f<T>('bitcast', x, y)
+export const cbrt = <T extends C>(x: X<T>) => f<T>('cbrt', x)
+export const difference = <T extends C>(x: X<T>, y: X) => f<T>('difference', x, y)
+export const equals = (x: X, y: X) => f<'bool'>('equals', x, y)
+export const faceforward = <T extends C>(N: X<T>, I: X, Nref: X) => f<T>('faceforward', N, I, Nref)
+export const transformDirection = <T extends C>(dir: X<T>, matrix: X) => f<T>('transformDirection', dir, matrix)

package/src/node/infer.ts

@@ -1,96 +1,91 @@
 import { is } from '../utils/helpers'
 import {
-        BOOL_RETURN_FUNCTIONS,
         BUILTIN_TYPES,
         COMPARISON_OPERATORS,
         COMPONENT_COUNT_TO_TYPE,
-        CONSTANTS,
-        FIRST_ARG_TYPE_FUNCTIONS,
-        HIGHEST_TYPE_FUNCTIONS,
+        FUNCTION_RETURN_TYPES,
         LOGICAL_OPERATORS,
-        PRESERVE_TYPE_FUNCTIONS,
-        SCALAR_RETURN_FUNCTIONS,
-        VEC3_RETURN_FUNCTIONS,
-        VEC4_RETURN_FUNCTIONS,
 } from './const'
-import { isConstantsType, isNodeProxy } from './utils'
-import type { Constants, NodeContext, NodeProxy, X } from './types'
+import { isConstants, isNodeProxy, isSwizzle } from './utils'
+import type { Constants as C, NodeContext, NodeProxy, X } from './types'
 
-const getHighestPriorityType = (args: X[], c: NodeContext) => {
-        return args.reduce((highest, current) => {
-                const currentType = infer(current, c)
-                const highestPriority = CONSTANTS.indexOf(highest as any)
-                const currentPriority = CONSTANTS.indexOf(currentType as any)
-                return currentPriority > highestPriority ? currentType : highest
-        }, 'float') as Constants
+const inferBuiltin = <T extends C>(id: string | undefined) => {
+        return BUILTIN_TYPES[id as keyof typeof BUILTIN_TYPES] as T
 }
 
-const inferBuiltin = (id: string | undefined): Constants => {
-        return BUILTIN_TYPES[id as keyof typeof BUILTIN_TYPES]!
+// Unified logic with types.ts InferOperator type
+const inferOperator = <T extends C>(L: T, R: T, op: string): T => {
+        if (COMPARISON_OPERATORS.includes(op as any) || LOGICAL_OPERATORS.includes(op as any)) return 'bool' as T
+        if (L === R) return L
+        // broadcast
+        if (L === 'float' || L === 'int') return R
+        if (R === 'float' || R === 'int') return L
+        // mat * vec → vec
+        if (L === 'mat4' && R === 'vec4') return R
+        if (L === 'mat3' && R === 'vec3') return R
+        if (L === 'mat2' && R === 'vec2') return R
+        // vec * mat → vec
+        if (L === 'vec4' && R === 'mat4') return L
+        if (L === 'vec3' && R === 'mat3') return L
+        if (L === 'vec2' && R === 'mat2') return L
+        return L
 }
 
-const inferFunction = (funcName: string, args: X[], c: NodeContext): Constants => {
-        const firstArgType = args.length > 0 ? infer(args[0], c) : 'float'
-        if (FIRST_ARG_TYPE_FUNCTIONS.includes(funcName as any)) return firstArgType
-        if (SCALAR_RETURN_FUNCTIONS.includes(funcName as any)) return 'float'
-        if (BOOL_RETURN_FUNCTIONS.includes(funcName as any)) return 'bool'
-        if (PRESERVE_TYPE_FUNCTIONS.includes(funcName as any)) return firstArgType
-        if (VEC3_RETURN_FUNCTIONS.includes(funcName as any)) return 'vec3'
-        if (VEC4_RETURN_FUNCTIONS.includes(funcName as any)) return 'vec4'
-        if (HIGHEST_TYPE_FUNCTIONS.includes(funcName as any)) return getHighestPriorityType(args, c)
-        return firstArgType
+export const inferPrimitiveType = <T extends C>(x: X) => {
+        if (is.bol(x)) return 'bool' as T
+        if (is.str(x)) return 'texture' as T
+        if (is.num(x)) return 'float' as T // @TODO FIX:  Number.isInteger(x) ? 'int' : 'float'
+        if (is.arr(x)) return COMPONENT_COUNT_TO_TYPE[x.length as keyof typeof COMPONENT_COUNT_TO_TYPE] as T
+        return 'float' as T
 }
 
-const inferOperator = (leftType: string, rightType: string, op: string): Constants => {
-        if (COMPARISON_OPERATORS.includes(op as any)) return 'bool'
-        if (LOGICAL_OPERATORS.includes(op as any)) return 'bool'
-        if (leftType === rightType) return leftType as Constants
-        if (leftType.includes('vec') && !rightType.includes('vec')) return leftType as Constants
-        if (rightType.includes('vec') && !leftType.includes('vec')) return rightType as Constants
-        const leftPriority = CONSTANTS.indexOf(leftType as any)
-        const rightPriority = CONSTANTS.indexOf(rightType as any)
-        return (leftPriority >= rightPriority ? leftType : rightType) as Constants
+const inferFromCount = <T extends C>(count: number) => {
+        return COMPONENT_COUNT_TO_TYPE[count as keyof typeof COMPONENT_COUNT_TO_TYPE] as T
 }
 
-export const inferPrimitiveType = (x: any): Constants => {
-        if (is.bol(x)) return 'bool'
-        if (is.num(x)) return 'float'
-        if (is.arr(x)) return COMPONENT_COUNT_TO_TYPE[x.length as keyof typeof COMPONENT_COUNT_TO_TYPE] || 'float'
-        return 'float'
-}
-
-const inferSwizzle = (count: number): Constants => {
-        return COMPONENT_COUNT_TO_TYPE[count as keyof typeof COMPONENT_COUNT_TO_TYPE]!
-}
-
-const inferFromArray = (arr: X[], c: NodeContext): Constants => {
-        if (arr.length === 0) return 'void'
-        const ret = infer(arr[0], c)
+const inferFromArray = <T extends C>(arr: X<T>[], c: NodeContext) => {
+        if (arr.length === 0) return 'void' as T
+        const [x] = arr
+        if (is.str(x)) return x as T // for struct
+        const ret = infer(x, c)
         for (const x of arr.slice(1))
-                if (ret !== infer(x)) throw new Error(`glre node system error: defined scope return mismatch`)
+                if (ret !== infer(x, c)) throw new Error(`glre node system error: defined scope return mismatch`)
         return ret
 }
 
-export const inferImpl = (target: NodeProxy, c: NodeContext): Constants => {
+export const inferFunction = <T extends C>(x: X) => {
+        return FUNCTION_RETURN_TYPES[x as keyof typeof FUNCTION_RETURN_TYPES] as T
+}
+
+export const inferImpl = <T extends C>(target: NodeProxy<T>, c: NodeContext): T => {
         const { type, props } = target
-        const { id, children = [], layout, inferFrom } = props
+        const { id, children = [], inferFrom, layout } = props
         const [x, y, z] = children
-        if (type === 'conversion') return x as Constants
-        if (type === 'operator') return inferOperator(infer(y, c), infer(z, c), x as string)
-        if (type === 'function') return inferFunction(x as string, children.slice(1), c)
-        if (type === 'swizzle') return inferSwizzle((x as string).length)
+        if (type === 'conversion') return x
+        if (type === 'operator') return inferOperator(infer(y, c), infer(z, c), x)
         if (type === 'ternary') return inferOperator(infer(y, c), infer(z, c), 'add')
         if (type === 'builtin') return inferBuiltin(id)
-        if (type === 'define' && isConstantsType(layout?.type)) return layout?.type
+        if (type === 'function') return inferFunction(x) || infer(y, c)
+        if (type === 'define' && isConstants(layout?.type)) return layout?.type as T
+        if (type === 'attribute' && is.arr(x) && c.gl?.count) return inferFromCount(x.length / c.gl.count)
+        if (type === 'member') {
+                if (isSwizzle(x)) return inferFromCount(x.length)
+                if (isNodeProxy(y) && is.str(x)) {
+                        const field = (y as any).props.fields?.[x] // for variable node of struct member
+                        if (field) return infer(field, c)
+                }
+                return 'float' as T // fallback @TODO FIX
+        }
         if (inferFrom) return inferFromArray(inferFrom, c)
-        return infer(x, c)
+        return infer(x, c) // for uniform
 }
 
-export const infer = (target: X, c?: NodeContext | null): Constants => {
+export const infer = <T extends C>(target: X<T>, c?: NodeContext | null): T => {
         if (!c) c = {}
         if (!isNodeProxy(target)) return inferPrimitiveType(target)
-        if (!c.infers) c.infers = new WeakMap<NodeProxy, Constants>()
-        if (c.infers.has(target)) return c.infers.get(target)!
+        if (is.arr(target)) return inferFromCount(target.length)
+        if (!c.infers) c.infers = new WeakMap<NodeProxy<T>, C>()
+        if (c.infers.has(target)) return c.infers.get(target) as T
         const ret = inferImpl(target, c)
         c.infers.set(target, ret)
         return ret

package/src/node/node.ts

@@ -1,15 +1,17 @@
+import { is } from '../utils/helpers'
 import { code } from './code'
 import { assign, toVar } from './scope'
-import { conversionToConstant, isConversion, isFunction, isOperator, isSwizzle, getId, isNodeProxy } from './utils'
-import type { Functions, NodeProps, NodeProxy, NodeTypes, Operators, Swizzles, X } from './types'
+import { conversionToConstant, isConversion, isFunction, isOperator, getId } from './utils'
+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>()
         const get = (_: unknown, key: string | Symbol) => {
                 if (key === 'type') return type
                 if (key === 'props') return props
@@ -18,33 +20,34 @@ export const node = (type: NodeTypes, props?: NodeProps | null, ...args: X[]) =>
                 if (key === 'isProxy') return true
                 if (key === 'toString') return code.bind(null, x)
                 if (key === Symbol.toPrimitive) return toPrimitive.bind(null, x)
-                if (isSwizzle(key)) return swizzle(key, x)
+                if (key === 'listeners') return listeners
                 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 and swizzling
         }
         const set = (_: unknown, key: string, y: X) => {
-                if (isSwizzle(key)) {
-                        swizzle(key, x).assign(y)
-                        return true
-                }
-                return false
+                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 swizzle = (key: Swizzles, x: X) => node('swizzle', null, key, x)
-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 select = (x: X, y: X, z: X) => node('ternary', null, x, y, z) // x ? y : z
+// 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)