glre 0.37.0 → 0.39.0

package/src/node/types.ts

@@ -1,4 +1,4 @@
-import { CONSTANTS, CONVERSIONS, FUNCTIONS, OPERATOR_KEYS } from './utils/const'
+import { CONSTANTS, CONVERSIONS, FUNCTIONS, OPERATOR_KEYS, OPERATOR_TYPE_RULES } from './utils/const'
 import type { GL } from '../types'
 
 export type Constants = (typeof CONSTANTS)[number] | 'void'
@@ -6,17 +6,31 @@ export type Conversions = (typeof CONVERSIONS)[number]
 export type Functions = (typeof FUNCTIONS)[number]
 export type Operators = (typeof OPERATOR_KEYS)[number]
 
+/**
+ * scope
+ */
 export interface FnLayout {
         name: string
-        type: Constants | 'auto'
+        type: C | 'auto'
         inputs?: Array<{
                 name: string
-                type: Constants
+                type: C
         }>
 }
 
+export interface FnType<T extends X | Struct | void, Args extends any[]> {
+        (...args: Args): T extends void ? Void : T
+        setLayout(layout: FnLayout): FnType<T, Args>
+}
+
+export type StructFields = Record<string, X>
+
+export interface StructFactory<T extends StructFields> {
+        (initialValues?: StructFields, instanceId?: string): Struct<T>
+}
+
 /**
- * Node
+ * node
  */
 export type NodeTypes =
         // headers
@@ -47,8 +61,10 @@ export type NodeTypes =
         | 'switch'
         | 'declare'
         | 'return'
+        | 'break'
+        | 'continue'
 
-export interface NodeProps<T extends Record<string, NodeProxy> = {}> {
+export interface NodeProps {
         id?: string
         args?: any[]
         type?: string
@@ -56,8 +72,8 @@ export interface NodeProps<T extends Record<string, NodeProxy> = {}> {
         inferFrom?: any[]
         layout?: FnLayout
         // for struct
-        fields?: T
-        initialValues?: T
+        fields?: StructFields
+        initialValues?: StructFields
 }
 
 export interface NodeContext {
@@ -65,7 +81,7 @@ export interface NodeContext {
         label?: 'vert' | 'frag' | 'compute'
         isWebGL?: boolean
         units?: any // @TODO FIX
-        infers?: WeakMap<NodeProxy, Constants>
+        infers?: WeakMap<X, C>
         onMount?: (name: string) => void
         code?: {
                 headers: Map<string, string>
@@ -75,29 +91,24 @@ export interface NodeContext {
                 vertVaryings: Map<string, string>
                 computeInputs: Map<string, string>
                 dependencies: Map<string, Set<string>>
+                structStructFields: Map<string, StructFields>
         }
 }
 
 /**
  * infer
  */
-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
+// Optimized string length using direct pattern matching
+// prettier-ignore
+type _StringLength<A extends string> =
+        A extends `${infer _}${infer A}` ? A extends '' ? 1 :
+        A extends `${infer _}${infer B}` ? B extends '' ? 2 :
+        B extends `${infer _}${infer C}` ? C extends '' ? 3 :
+        4 : never : never : never
 
 // Unified logic with infer.ts inferOperator function
 // prettier-ignore
-type InferOperator<L extends Constants, R extends Constants> =
+type InferOperator<L extends C, R extends C> =
         L extends R ? L :
         // broadcast
         L extends 'float' | 'int' ? R :
@@ -113,19 +124,23 @@ type InferOperator<L extends Constants, R extends Constants> =
 
 // Unified logic with infer.ts inferArrayElement function
 // prettier-ignore
-type InferArrayElement<T extends Constants> =
+type InferArrayElement<T extends C> =
         T extends 'mat4' ? 'vec4' :
         T extends 'mat3' ? 'vec3' :
         T extends 'mat2' ? 'vec2' :
         'float'
 
-type InferSwizzleType<S extends string> = _StringLength<S> extends 4
-        ? 'vec4'
-        : _StringLength<S> extends 3
-        ? 'vec3'
-        : _StringLength<S> extends 2
-        ? 'vec2'
-        : 'float'
+type ExtractPairs<T> = T extends readonly [infer L, infer R, string] ? [L, R] | [R, L] : never
+type OperatorTypeRules = ExtractPairs<(typeof OPERATOR_TYPE_RULES)[number]>
+type IsInRules<L extends C, R extends C> = [L, R] extends OperatorTypeRules ? 1 : 0
+type ValidateOperator<L extends C, R extends C> = L extends R ? 1 : IsInRules<L, R>
+
+// prettier-ignore
+type InferSwizzleType<S extends string> =
+        _StringLength<S> extends 4 ? 'vec4' :
+        _StringLength<S> extends 3 ? 'vec3' :
+        _StringLength<S> extends 2 ? 'vec2' :
+        'float'
 
 /**
  * Swizzles
@@ -138,54 +153,38 @@ export type Swizzles =
         | _Swizzles<'p' | 'q'>
         | _Swizzles<'s' | 't'>
 
-type NodeProxyMethods =
-        | Functions
-        | Operators
-        | Conversions
-        | Swizzles
-        // system property
-        | 'type'
-        | 'props'
-        | 'isProxy'
-        | 'assign'
-        | 'toVar'
-        | 'toString'
-        | 'element'
-
-type ReadNodeProxy = {
-        [K in string as K extends NodeProxyMethods ? never : K]: any
+export type Void = XImpl<'void'>
+export type Bool = XImpl<'bool'>
+export type UInt = XImpl<'uint'>
+export type Int = XImpl<'int'>
+export type Float = XImpl<'float'>
+export type BVec2 = XImpl<'bvec2'>
+export type IVec2 = XImpl<'ivec2'>
+export type UVec2 = XImpl<'uvec2'>
+export type Vec2 = XImpl<'vec2'>
+export type BVec3 = XImpl<'bvec3'>
+export type IVec3 = XImpl<'ivec3'>
+export type UVec3 = XImpl<'uvec3'>
+export type Vec3 = XImpl<'vec3'>
+export type BVec4 = XImpl<'bvec4'>
+export type IVec4 = XImpl<'ivec4'>
+export type UVec4 = XImpl<'uvec4'>
+export type Vec4 = XImpl<'vec4'>
+export type Color = XImpl<'color'>
+export type Mat2 = XImpl<'mat2'>
+export type Mat3 = XImpl<'mat3'>
+export type Mat4 = XImpl<'mat4'>
+export type Texture = XImpl<'texture'>
+export type Sampler2D = XImpl<'sampler2D'>
+export type StructBase = XImpl<'struct'>
+export type Struct<T extends StructFields = any> = Omit<StructBase, keyof T> & {
+        [K in keyof T]: T[K] extends X<infer U> ? X<U> : never
 } & {
-        [K in Swizzles]: NodeProxy<InferSwizzleType<K>>
+        toVar(id?: string): Struct<T>
 }
 
-// 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 {
+        void: Void
         bool: Bool
         uint: UInt
         int: Int
@@ -208,51 +207,94 @@ export interface ConstantsToType {
         mat4: Mat4
         texture: Texture
         sampler2D: Sampler2D
-        struct: Struct
+        struct: StructBase
+}
+
+/**
+ * X and Y
+ */
+type XImpl<T extends C> = _X<T> & {
+        [K in string as K extends Methods ? never : K]: any
+} & {
+        [K in Swizzles]: X<InferSwizzleType<K>>
 }
 
-export type NodeProxy<T extends Constants = string> = T extends keyof ConstantsToType
-        ? ConstantsToType[T]
-        : NodeProxyImpl<T>
+type C = Constants
 
-export type X<T extends Constants = string> = number | string | boolean | undefined | NodeProxy<T> | X[]
+export type X<T extends C = C> = T extends keyof ConstantsToType ? ConstantsToType[T] : _X<T>
+export type Y<T extends C = C> = number | number[] | string | boolean | undefined | X<T>
 
-export interface BaseNodeProxy<T extends Constants> {
+type Methods =
+        | Functions
+        | Operators
+        | Conversions
+        | Swizzles
+        // system property
+        | '__nodeType'
+        | 'type'
+        | 'props'
+        | 'isProxy'
+        | 'assign'
+        | 'toVar'
+        | 'toString'
+        | 'element'
+
+interface _X<T extends C> {
         // System properties
-        assign(x: any): NodeProxy<T>
-        toVar(name?: string): NodeProxy<T>
+        readonly __nodeType?: T
+        assign(x: any): X<T>
+        fragment(c: NodeContext): string
+        toVar(name?: string): X<T>
         toString(c?: NodeContext): string
+        fragment(c?: NodeContext): string
+        compute(c?: NodeContext): string
+        vertex(c?: NodeContext): string
         type: NodeTypes
         props: NodeProps
         isProxy: true
         listeners: Set<(value: any) => void>
 
         // Element access for array/matrix types
-        element<Index extends X>(index: Index): NodeProxy<InferArrayElement<T>>
-
-        // Operators methods
-        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
+        element<Index extends X>(index: Index): X<InferArrayElement<T>>
+
+        // Enhanced member access with type preservation
+        member<K extends string>(key: K): K extends keyof T ? (T[K] extends X<infer U> ? X<U> : never) : never
+
+        // Operators methods with unified type validation
+        add<U extends C>(x: ValidateOperator<T, U> extends 0 ? never : number | X<U>): X<InferOperator<T, U>>
+        sub<U extends C>(x: ValidateOperator<T, U> extends 0 ? never : number | X<U>): X<InferOperator<T, U>>
+        mul<U extends C>(x: ValidateOperator<T, U> extends 0 ? never : number | X<U>): X<InferOperator<T, U>>
+        div<U extends C>(x: ValidateOperator<T, U> extends 0 ? never : number | X<U>): X<InferOperator<T, U>>
+        mod<U extends C>(x: ValidateOperator<T, U> extends 0 ? never : number | X<U>): X<InferOperator<T, U>>
+        equal<U extends C>(x: ValidateOperator<T, U> extends 0 ? never : number | X<U>): Bool
+        notEqual<U extends C>(x: ValidateOperator<T, U> extends 0 ? never : number | X<U>): Bool
+        lessThan<U extends C>(x: ValidateOperator<T, U> extends 0 ? never : number | X<U>): Bool
+        lessThanEqual<U extends C>(x: ValidateOperator<T, U> extends 0 ? never : number | X<U>): Bool
+        greaterThan<U extends C>(x: ValidateOperator<T, U> extends 0 ? never : number | X<U>): Bool
+        greaterThanEqual<U extends C>(x: ValidateOperator<T, U> extends 0 ? never : number | X<U>): Bool
+        and(x: Bool): Bool
+        or(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>>
+        bitAnd(x: X<T>): X<T>
+        bitOr(x: X<T>): X<T>
+        bitXor(x: X<T>): X<T>
+        bitNot(): X<T>
+        shiftLeft<U extends C>(x: X<U>): X<InferOperator<T, U>>
+        shiftRight<U extends C>(x: X<U>): X<InferOperator<T, U>>
+
+        // Assignment operators
+        addAssign<U extends C>(x: ValidateOperator<T, U> extends 0 ? never : number | X<U>): X<T>
+        subAssign<U extends C>(x: ValidateOperator<T, U> extends 0 ? never : number | X<U>): X<T>
+        mulAssign<U extends C>(x: ValidateOperator<T, U> extends 0 ? never : number | X<U>): X<T>
+        divAssign<U extends C>(x: ValidateOperator<T, U> extends 0 ? never : number | X<U>): X<T>
+        modAssign<U extends C>(x: ValidateOperator<T, U> extends 0 ? never : number | X<U>): X<T>
+        bitAndAssign<U extends C>(x: ValidateOperator<T, U> extends 0 ? never : number | X<U>): X<T>
+        bitOrAssign<U extends C>(x: ValidateOperator<T, U> extends 0 ? never : number | X<U>): X<T>
+        bitXorAssign<U extends C>(x: ValidateOperator<T, U> extends 0 ? never : number | X<U>): X<T>
+        shiftLeftAssign<U extends C>(x: ValidateOperator<T, U> extends 0 ? never : number | X<U>): X<T>
+        shiftRightAssign<U extends C>(x: ValidateOperator<T, U> extends 0 ? never : number | X<U>): X<T>
 
         // Conversion methods
         toBool(): Bool
@@ -284,15 +326,26 @@ export interface BaseNodeProxy<T extends Constants> {
         // 0. Always return bool
         all(): Bool
         any(): Bool
-        // 2. Always return float
-        determinant(): Float
-        distance<U extends Constants>(y: X<U>): Float
-        dot<U extends Constants>(y: X<U>): Float
-        length(): Float
+
+        // 2. WGSL-compliant return types with individual function constraints
+        determinant(): T extends 'mat2' | 'mat3' | 'mat4' ? Float : never
+        distance<U extends C>(
+                y: T extends 'vec2' | 'vec3' | 'vec4' ? (U extends T ? number | X<U> : never) : never
+        ): Float
+        dot<U extends C>(
+                y: T extends 'vec2' | 'vec3' | 'vec4' | 'ivec2' | 'ivec3' | 'ivec4'
+                        ? U extends T
+                                ? number | X<U>
+                                : never
+                        : never
+        ): T extends `ivec${string}` ? Int : Float
+        length(): T extends 'vec2' | 'vec3' | 'vec4' ? Float : never
         lengthSq(): Float
         luminance(): Float
-        // 3. Always return vec3
-        cross<U extends Constants>(y: X<U>): Vec3
+
+        // 3. Always return vec3 with vector constraint
+        cross<U extends C = 'vec3'>(y: T extends 'vec3' ? (U extends 'vec3' ? number | X<U> : never) : never): Vec3
+
         // 4. Always return vec4
         cubeTexture(...args: X[]): Vec4
         texture(...args: X[]): Vec4
@@ -300,59 +353,64 @@ export interface BaseNodeProxy<T extends Constants> {
         textureLod(...args: X[]): Vec4
 
         /**
-         * 3.1. unified with:
-         * 1.1. index.ts functions and
-         * 2.1. const.ts FUNCTIONS
+         * 3.2. unified with:
+         * 1.2. index.ts functions and
+         * 2.2. const.ts FUNCTIONS
          */
-        // 0. Component-wise functions
-        abs(): NodeProxy
-        acos(): NodeProxy
-        acosh(): NodeProxy
-        asin(): NodeProxy
-        asinh(): NodeProxy
-        atan(): NodeProxy
-        atanh(): NodeProxy
-        ceil(): NodeProxy
-        cos(): NodeProxy
-        cosh(): NodeProxy
-        degrees(): NodeProxy
-        dFdx(): NodeProxy
-        dFdy(): NodeProxy
-        exp(): NodeProxy
-        exp2(): NodeProxy
-        floor(): NodeProxy
-        fract(): NodeProxy
-        fwidth(): NodeProxy
-        inverseSqrt(): NodeProxy
-        log(): NodeProxy
-        log2(): NodeProxy
-        negate(): NodeProxy
-        normalize(): NodeProxy
-        oneMinus(): NodeProxy
-        radians(): NodeProxy
-        reciprocal(): NodeProxy
-        round(): NodeProxy
-        saturate(): NodeProxy
-        sign(): NodeProxy
-        sin(): NodeProxy
-        sinh(): NodeProxy
-        sqrt(): NodeProxy
-        tan(): NodeProxy
-        tanh(): NodeProxy
-        trunc(): NodeProxy
-
-        // 1. Functions where first argument determines return type
-        atan2<U extends Constants>(x: X<U>): NodeProxy<T>
-        clamp<U extends Constants, V>(mix: X<U>, max: V): NodeProxy<InferOperator<T, U>>
-        max<U extends Constants>(y: X<U>): NodeProxy<InferOperator<T, U>>
-        min<U extends Constants>(y: X<U>): NodeProxy<InferOperator<T, U>>
-        mix<U extends Constants, V>(y: X<U>, a: V): NodeProxy<InferOperator<T, U>>
-        pow<U extends Constants>(y: X<U>): NodeProxy<T>
-        reflect<U extends Constants>(N: X<U>): NodeProxy<T>
-        refract<U extends Constants>(N: X<U>, eta: any): NodeProxy<T>
-
-        // 2. Functions where not first argument determines return type
-        smoothstep<U extends Constants, V>(edge0: X<U>, edge1: V): NodeProxy<InferOperator<T, U>>
-        step<U extends Constants>(edge: X<U>): NodeProxy<InferOperator<T, U>>
+        // 0. Component-wise functions with type validation
+        abs(): X<T>
+        acos(): X<T>
+        acosh(): X<T>
+        asin(): X<T>
+        asinh(): X<T>
+        atan(): X<T>
+        atanh(): X<T>
+        ceil(): X<T>
+        cos(): X<T>
+        cosh(): X<T>
+        degrees(): X<T>
+        dFdx(): X<T>
+        dFdy(): X<T>
+        exp(): X<T>
+        exp2(): X<T>
+        floor(): X<T>
+        fract(): X<T>
+        fwidth(): X<T>
+        inverseSqrt(): X<T>
+        log(): X<T>
+        log2(): X<T>
+        negate(): X<T>
+        normalize(): T extends 'vec2' | 'vec3' | 'vec4' ? X<T> : never
+        oneMinus(): X<T>
+        radians(): X<T>
+        reciprocal(): X<T>
+        round(): X<T>
+        saturate(): X<T>
+        sign(): X<T>
+        sin(): X<T>
+        sinh(): X<T>
+        sqrt(): X<T>
+        tan(): X<T>
+        tanh(): X<T>
+        trunc(): X<T>
+
+        // 1. Functions where first argument determines return type with unified parameter types
+        atan2<U extends C>(x: number | X<U>): X<T>
+        clamp<U extends C>(min: number | X<U>, max: number | X<U>): X<InferOperator<T, U>>
+        max<U extends C>(y: number | X<U>): X<InferOperator<T, U>>
+        min<U extends C>(y: number | X<U>): X<InferOperator<T, U>>
+        mix<U extends C>(y: number | X<U>, a: number | Float | X<U>): X<InferOperator<T, U>>
+        pow<U extends C>(y: number | X<U>): X<T>
+        reflect<U extends C>(
+                N: T extends 'vec2' | 'vec3' | 'vec4' ? (U extends T ? number | X<U> : never) : never
+        ): X<T>
+        refract<U extends C>(
+                N: T extends 'vec2' | 'vec3' | 'vec4' ? (U extends T ? number | X<U> : never) : never,
+                eta: number | Float
+        ): T extends 'vec2' | 'vec3' | 'vec4' ? X<T> : never
+
+        // 2. Functions where not first argument determines return type with unified parameter types
+        smoothstep<U extends C>(edge0: number | X<U>, edge1: number | X<U>): X<InferOperator<T, U>>
+        step<U extends C>(edge: number | X<U>): X<InferOperator<T, U>>
         // @NOTE: mod is operator
 }

package/src/node/utils/const.ts

@@ -51,9 +51,10 @@ export const TYPE_MAPPING = {
         struct: 'struct',
 } as const
 
-export const CONSTANTS = Object.keys(TYPE_MAPPING) as unknown as keyof typeof TYPE_MAPPING
+export const CONSTANTS = Object.keys(TYPE_MAPPING) as (keyof typeof TYPE_MAPPING)[]
 
 export const OPERATORS = {
+        not: '', // IGNORED
         add: '+',
         sub: '-',
         mul: '*',
@@ -72,6 +73,16 @@ export const OPERATORS = {
         bitXor: '^',
         shiftLeft: '<<',
         shiftRight: '>>',
+        addAssign: '+=',
+        subAssign: '-=',
+        mulAssign: '*=',
+        divAssign: '/=',
+        modAssign: '%=',
+        bitAndAssign: '&=',
+        bitOrAssign: '|=',
+        bitXorAssign: '^=',
+        shiftLeftAssign: '<<=',
+        shiftRightAssign: '>>=',
 } as const
 
 export const OPERATOR_KEYS = Object.keys(OPERATORS) as (keyof typeof OPERATORS)[]
@@ -134,6 +145,28 @@ export const COMPARISON_OPERATORS = [
 
 export const LOGICAL_OPERATORS = ['and', 'or'] as const
 
+// Operator type rules [L, R, Result] format (no duplicates, same-type handled by logic)
+export const OPERATOR_TYPE_RULES = [
+        // Scalar broadcast operations (result follows vector type)
+        ['float', 'vec2', 'vec2'],
+        ['float', 'vec3', 'vec3'],
+        ['float', 'vec4', 'vec4'],
+        ['int', 'ivec2', 'ivec2'],
+        ['int', 'ivec3', 'ivec3'],
+        ['int', 'ivec4', 'ivec4'],
+        ['uint', 'uvec2', 'uvec2'],
+        ['uint', 'uvec3', 'uvec3'],
+        ['uint', 'uvec4', 'uvec4'],
+        // Matrix-vector operations (mat * vec → vec)
+        ['mat2', 'vec2', 'vec2'],
+        ['mat3', 'vec3', 'vec3'],
+        ['mat4', 'vec4', 'vec4'],
+        // Vector-matrix operations (vec * mat → vec)
+        ['vec2', 'mat2', 'vec2'],
+        ['vec3', 'mat3', 'vec3'],
+        ['vec4', 'mat4', 'vec4'],
+] as const
+
 export const WGSL_TO_GLSL_BUILTIN = {
         position: 'gl_FragCoord',
         vertex_index: 'gl_VertexID',
@@ -149,7 +182,7 @@ export const WGSL_TO_GLSL_BUILTIN = {
 /**
  * 2.1. unified with:
  * 1.1. index.ts functions and
- * 3.1. types.ts BaseNodeProxy
+ * 3.1. types.ts _N
  */
 // Function return type mapping for method chaining
 export const FUNCTION_RETURN_TYPES = {
@@ -175,7 +208,7 @@ export const FUNCTION_RETURN_TYPES = {
 /**
  * 2.2. unified with:
  * 1.2. index.ts functions and
- * 3.2. types.ts BaseNodeProxy
+ * 3.2. types.ts _N
  */
 // All shader functions (type inference now handled by inferFrom)
 export const FUNCTIONS = [
@@ -230,3 +263,31 @@ export const FUNCTIONS = [
         'step',
         // @NOTE: mod is operator
 ] as const
+
+// Check if two types are the same (for same-type operations)
+const isSameType = (L: string, R: string): boolean => L === R
+
+// Check if combination exists in rules (handles bidirectional matching)
+const isValidCombination = (L: string, R: string): boolean => {
+        return OPERATOR_TYPE_RULES.some(
+                ([left, right, _]) => (left === L && right === R) || (left === R && right === L)
+        )
+}
+
+// Type constraint validation for operators ([L, R, Result] format)
+export const validateOperatorTypes = (L: string, R: string, op: string): boolean => {
+        if (COMPARISON_OPERATORS.includes(op as any) || LOGICAL_OPERATORS.includes(op as any)) return isSameType(L, R)
+        if (isSameType(L, R)) return true
+        return isValidCombination(L, R)
+}
+
+// Get result type for operator (used by inferOperator)
+export const getOperatorResultType = (L: string, R: string, op: string): string => {
+        if (COMPARISON_OPERATORS.includes(op as any) || LOGICAL_OPERATORS.includes(op as any)) return 'bool'
+        // Same type operations return the same type
+        if (isSameType(L, R)) return L
+        const rule = OPERATOR_TYPE_RULES.find(
+                ([left, right, _]) => (left === L && right === R) || (left === R && right === L)
+        )
+        return rule ? rule[2] : L
+}

package/src/node/utils/index.ts

@@ -16,13 +16,13 @@ import {
         parseUniformHead,
         parseVaryingHead,
 } from './parse'
-import { getBluiltin, getOperator, getConversions, safeEventCall, getEventFun, initNodeContext } from './utils'
+import { getBluiltin, getConversions, getEventFun, getOperator, initNodeContext, safeEventCall } from './utils'
 import { is } from '../../utils/helpers'
-import type { Constants, NodeContext, X } from '../types'
+import type { Constants as C, NodeContext, Y } from '../types'
 
 export * from './utils'
 
-export const code = <T extends Constants>(target: X<T>, c?: NodeContext | null): string => {
+export const code = <T extends C>(target: Y<T>, c?: NodeContext | null): string => {
         if (!c) c = {}
         initNodeContext(c)
         if (is.arr(target)) return parseArray(target, c)
@@ -62,6 +62,7 @@ export const code = <T extends Constants>(target: X<T>, c?: NodeContext | null):
         if (type === 'conversion') return `${getConversions(x, c)}(${parseArray(children.slice(1), c)})`
         if (type === 'operator') {
                 if (x === 'not' || x === 'bitNot') return `!${code(y, c)}`
+                if (x.endsWith('Assign')) return `${code(y, c)} ${getOperator(x)} ${code(z, c)};`
                 return `(${code(y, c)} ${getOperator(x)} ${code(z, c)})`
         }
         if (type === 'function') {
@@ -77,6 +78,8 @@ export const code = <T extends Constants>(target: X<T>, c?: NodeContext | null):
         if (type === 'scope') return children.map((child: any) => code(child, c)).join('\n')
         if (type === 'assign') return `${code(x, c)} = ${code(y, c)};`
         if (type === 'return') return `return ${code(x, c)};`
+        if (type === 'break') return 'break;'
+        if (type === 'continue') return 'continue;'
         if (type === 'loop')
                 return c.isWebGL
                         ? `for (int ${id} = 0; ${id} < ${code(x, c)}; ${id} += 1) {\n${code(y, c)}\n}`
@@ -85,12 +88,12 @@ export const code = <T extends Constants>(target: X<T>, c?: NodeContext | null):
         if (type === 'switch') return parseSwitch(c, x, children)
         if (type === 'declare') return parseDeclare(c, x, y)
         if (type === 'define') {
-                if (!c.code?.headers.has(id)) c.code?.headers.set(id, parseDefine(c, props, infer(target, c)))
+                if (!c.code?.headers.has(id)) c.code?.headers.set(id, parseDefine(c, props, target))
                 return `${id}(${parseArray(children.slice(1), c)})`
         }
         if (type === 'struct') {
                 if (!c.code?.headers.has(id)) c.code?.headers.set(id, parseStructHead(c, id, fields))
-                return parseStruct(c, id, x.props.id, fields, initialValues)
+                return parseStruct(c, id, x.props.id, initialValues)
         }
         /**
          * headers