glre 0.37.0 → 0.39.0

package/src/node/utils/infer.ts

@@ -1,37 +1,25 @@
-import { isConstants, isNodeProxy, isSwizzle } from './utils'
+import { isConstants, isX, isSwizzle } from './utils'
 import {
         BUILTIN_TYPES,
-        COMPARISON_OPERATORS,
         COMPONENT_COUNT_TO_TYPE,
         FUNCTION_RETURN_TYPES,
-        LOGICAL_OPERATORS,
+        getOperatorResultType,
+        validateOperatorTypes,
 } from './const'
 import { is } from '../../utils/helpers'
-import type { Constants as C, NodeContext, NodeProxy, X } from '../types'
+import type { Constants as C, NodeContext, X, Y } from '../types'
 
 const inferBuiltin = <T extends C>(id: string | undefined) => {
         return BUILTIN_TYPES[id as keyof typeof BUILTIN_TYPES] as T
 }
 
-// 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
+        if (!validateOperatorTypes(L, R, op))
+                console.warn(`GLRE Type Warning: Invalid operator '${op}' between types '${L}' and '${R}'`)
+        return getOperatorResultType(L, R, op) as T
 }
 
-export const inferPrimitiveType = <T extends C>(x: X) => {
+export const inferPrimitiveType = <T extends C>(x: Y<T>) => {
         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'
@@ -43,27 +31,26 @@ const inferFromCount = <T extends C>(count: number) => {
         return COMPONENT_COUNT_TO_TYPE[count as keyof typeof COMPONENT_COUNT_TO_TYPE] as T
 }
 
-const inferFromArray = <T extends C>(arr: X<T>[], c: NodeContext) => {
+const inferFromArray = <T extends C>(arr: Y<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, c)) throw new Error(`glre node system error: defined scope return mismatch`)
+        // for (const x of arr.slice(1))
+        //         if (ret !== infer(x, c)) throw new Error(`glre node system error: defined scope return mismatch`)
         return ret
 }
 
-export const inferFunction = <T extends C>(x: X) => {
+export const inferFunction = <T extends C>(x: Y) => {
         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 => {
+export const inferImpl = <T extends C>(target: X<T>, c: NodeContext): T => {
         const { type, props } = target
         const { id, children = [], inferFrom, layout } = props
         const [x, y, z] = children
         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 === 'function') return inferFunction(x) || infer(y, c)
         if (type === 'define') {
@@ -74,23 +61,24 @@ export const inferImpl = <T extends C>(target: NodeProxy<T>, c: NodeContext): T
         if (type === 'attribute' && is.arr(x) && c.gl?.count) return inferFromCount(x.length / c.gl.count)
         if (type === 'member') {
                 if (isSwizzle(y)) return inferFromCount(y.length)
-                if (isNodeProxy(x)) {
-                        const field = (x as any).props.fields[y] // for variable node of struct member
-                        if (field) return infer(field, c)
+                if (isX(x)) {
+                        const structType = infer(x, c)
+                        const fields = c.code?.structStructFields?.get(structType)
+                        if (fields && fields[y]) return infer(fields[y], c) as T
                 }
-                return 'float' as T // fallback @TODO FIX
+                return 'float' as T
         }
         if (inferFrom) return inferFromArray(inferFrom, c)
-        return infer(x, c) // for uniform and storage gather and scatter
+        return x ? infer(x, c) : ('void' as T) // for uniform and storage gather and scatter
 }
 
-export const infer = <T extends C>(target: X<T>, c?: NodeContext | null): T => {
+export const infer = <T extends C>(target: Y<T>, c?: NodeContext | null): T => {
         if (!c) c = {}
-        if (!isNodeProxy(target)) return inferPrimitiveType(target)
+        if (!isX(target)) return inferPrimitiveType(target)
         if (is.arr(target)) return inferFromCount(target.length)
-        if (!c.infers) c.infers = new WeakMap<NodeProxy<T>, C>()
+        if (!c.infers) c.infers = new WeakMap<X<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
+        return ret as T
 }

package/src/node/utils/parse.ts

@@ -2,9 +2,9 @@ import { code } from '.'
 import { infer } from './infer'
 import { getConversions, addDependency } from './utils'
 import { is } from '../../utils/helpers'
-import type { Constants, NodeContext, NodeProps, NodeProxy, X } from '../types'
+import type { Constants, NodeContext, NodeProps, StructFields, Y } from '../types'
 
-export const parseArray = (children: X[], c: NodeContext) => {
+export const parseArray = (children: Y[], c: NodeContext) => {
         return children
                 .filter((x) => !is.und(x) && !is.nul(x))
                 .map((x) => code(x, c))
@@ -12,7 +12,7 @@ export const parseArray = (children: X[], c: NodeContext) => {
 }
 
 // only for webgl
-export const parseGather = (c: NodeContext, x: X, y: X, target: X) => {
+export const parseGather = (c: NodeContext, x: Y, y: Y, target: Y) => {
         const parseSwizzle = () => {
                 const valueType = infer(target, c)
                 if (valueType === 'float') return '.x'
@@ -29,7 +29,7 @@ export const parseGather = (c: NodeContext, x: X, y: X, target: X) => {
 }
 
 // only for webgl
-export const parseScatter = (c: NodeContext, storageNode: X, valueNode: X) => {
+export const parseScatter = (c: NodeContext, storageNode: Y, valueNode: Y) => {
         const storageId = code(storageNode, c)
         const valueCode = code(valueNode, c)
         const valueType = infer(valueNode, c)
@@ -40,7 +40,7 @@ export const parseScatter = (c: NodeContext, storageNode: X, valueNode: X) => {
         throw new Error(`Unsupported storage scatter type: ${valueType}`)
 }
 
-export const parseTexture = (c: NodeContext, y: X, z: X, w: X) => {
+export const parseTexture = (c: NodeContext, y: Y, z: Y, w: Y) => {
         if (c.isWebGL) {
                 const args = w ? [y, z, w] : [y, z]
                 return `texture(${parseArray(args, c)})`
@@ -55,7 +55,7 @@ export const parseTexture = (c: NodeContext, y: X, z: X, w: X) => {
 /**
  * scopes
  */
-export const parseIf = (c: NodeContext, x: X, y: X, children: X[]) => {
+export const parseIf = (c: NodeContext, x: Y, y: Y, children: Y[]) => {
         let ret = `if (${code(x, c)}) {\n${code(y, c)}\n}`
         for (let i = 2; i < children.length; i += 2) {
                 const isElse = i >= children.length - 1
@@ -66,7 +66,7 @@ export const parseIf = (c: NodeContext, x: X, y: X, children: X[]) => {
         return ret
 }
 
-export const parseSwitch = (c: NodeContext, x: X, children: X[]) => {
+export const parseSwitch = (c: NodeContext, x: Y, children: Y[]) => {
         let ret = `switch (${code(x, c)}) {\n`
         for (let i = 1; i < children.length; i += 2) {
                 const isDefault = i >= children.length - 1
@@ -79,7 +79,7 @@ export const parseSwitch = (c: NodeContext, x: X, children: X[]) => {
         return ret
 }
 
-export const parseDeclare = (c: NodeContext, x: X, y: X) => {
+export const parseDeclare = (c: NodeContext, x: Y, y: Y) => {
         const type = infer(x, c)
         const varName = (y as any)?.props?.id
         if (c.isWebGL) return `${type} ${varName} = ${code(x, c)};`
@@ -87,7 +87,8 @@ export const parseDeclare = (c: NodeContext, x: X, y: X) => {
         return `var ${varName}: ${wgslType} = ${code(x, c)};`
 }
 
-export const parseStructHead = (c: NodeContext, id: string, fields: Record<string, NodeProxy> = {}) => {
+export const parseStructHead = (c: NodeContext, id: string, fields: StructFields = {}) => {
+        c.code?.structStructFields?.set(id, fields)
         const lines: string[] = []
         for (const key in fields) {
                 const fieldType = fields[key]
@@ -99,13 +100,8 @@ export const parseStructHead = (c: NodeContext, id: string, fields: Record<strin
         return `struct ${id} {\n  ${ret}\n};`
 }
 
-export const parseStruct = (
-        c: NodeContext,
-        id: string,
-        instanceId = '',
-        fields?: Record<string, NodeProxy>,
-        initialValues?: Record<string, NodeProxy>
-) => {
+export const parseStruct = (c: NodeContext, id: string, instanceId = '', initialValues?: StructFields) => {
+        const fields = c.code?.structStructFields?.get(id) || {}
         if (c.isWebGL) {
                 if (initialValues) {
                         const ordered = []
@@ -124,7 +120,7 @@ export const parseStruct = (
 /**
  * define
  */
-export const parseDefine = (c: NodeContext, props: NodeProps, returnType: Constants) => {
+export const parseDefine = (c: NodeContext, props: NodeProps, target: Y) => {
         const { id, children = [], layout } = props
         const [x, ...args] = children
         const argParams: [name: string, type: string][] = []
@@ -137,6 +133,8 @@ export const parseDefine = (c: NodeContext, props: NodeProps, returnType: Consta
                 for (let i = 0; i < args.length; i++) {
                         argParams.push([`p${i}`, infer(args[i], c)])
                 }
+        const scopeCode = code(x, c) // build struct headers before inferring returnType
+        const returnType = infer(target, c)
         const ret = []
         if (c?.isWebGL) {
                 for (const [paramId, type] of argParams) {
@@ -152,7 +150,6 @@ export const parseDefine = (c: NodeContext, props: NodeProps, returnType: Consta
                         ret.push(`fn ${id}(${params}) {`)
                 } else ret.push(`fn ${id}(${params}) -> ${getConversions(returnType, c)} {`)
         }
-        const scopeCode = code(x, c)
         if (scopeCode) ret.push(scopeCode)
         ret.push('}')
         return ret.join('\n')

package/src/node/utils/utils.ts

@@ -8,7 +8,7 @@ import {
         WGSL_TO_GLSL_BUILTIN,
 } from './const'
 import { is } from '../../utils/helpers'
-import type { Constants, Conversions, Functions, NodeContext, NodeProxy, Operators, Swizzles, X } from '../types'
+import type { Constants as C, Conversions, Functions, NodeContext, Operators, Swizzles, X, Y } from '../types'
 
 export const isSwizzle = (key: unknown): key is Swizzles => {
         return is.str(key) && /^[xyzwrgbastpq]{1,4}$/.test(key)
@@ -26,15 +26,15 @@ export const isConversion = (key: unknown): key is Conversions => {
         return CONVERSIONS.includes(key as Conversions)
 }
 
-export const isNodeProxy = <T extends Constants>(x: unknown): x is NodeProxy<T> => {
+export const isX = (x: unknown): x is X => {
         if (!x) return false
         if (typeof x !== 'object') return false // @ts-ignore
         return x.isProxy
 }
 
-export const isConstants = (type?: unknown): type is Constants => {
+export const isConstants = (type?: unknown): type is C => {
         if (!is.str(type)) return false
-        return CONSTANTS.includes(type)
+        return CONSTANTS.includes(type as any)
 }
 
 export const hex2rgb = (hex: number) => {
@@ -58,17 +58,17 @@ export const getBluiltin = (c: NodeContext, id: string) => {
         return ret
 }
 
-export const getConversions = <T extends Constants>(x: X<T>, c?: NodeContext) => {
+export const getConversions = <T extends C>(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<string>) => {
+export const getOperator = (op: Y) => {
         return OPERATORS[op as keyof typeof OPERATORS] || op
 }
 
-export const getConstant = (conversionKey: string): Constants => {
+export const getConstant = (conversionKey: string): C => {
         const index = CONVERSIONS.indexOf(conversionKey as Conversions)
         return index !== -1 ? CONSTANTS[index] : 'float'
 }
@@ -84,13 +84,13 @@ export const getEventFun = (c: NodeContext, id: string, isAttribute = false, isT
         return (value: any) => c.gl?._uniform?.(id, value)
 }
 
-export const safeEventCall = <T extends Constants>(x: X<T>, fun: (value: unknown) => void) => {
+export const safeEventCall = <T extends C>(x: X<T>, fun: (value: unknown) => void) => {
         if (is.und(x)) return
-        if (!isNodeProxy(x)) return fun(x) // for uniform(1)
+        if (!isX(x)) return fun(x) // for uniform(0) or uniform([0, 1])
         if (x.type !== 'conversion') return
-        const value = x.props.children?.slice(1).filter(Boolean)
-        if (!value?.length) return // for uniform(vec2())
-        fun(value)
+        const args = x.props.children?.slice(1)
+        if (is.und(args?.[0])) return // ignore if uniform(vec2())
+        fun(args.map((x) => x ?? args[0])) // for uniform(vec2(1)) or uniform(vec2(1, 1))
 }
 
 export const initNodeContext = (c: NodeContext) => {
@@ -103,6 +103,7 @@ export const initNodeContext = (c: NodeContext) => {
                 vertVaryings: new Map(),
                 computeInputs: new Map(),
                 dependencies: new Map(),
+                structStructFields: new Map(),
         }
         if (c.isWebGL) return c
         c.code.fragInputs.set('position', '@builtin(position) position: vec4f')

package/src/types.ts

@@ -1,7 +1,6 @@
 import type { EventState, Nested } from 'reev'
-import type { Fun, Queue, Frame } from 'refr'
-import type { NodeProxy, Vec4 } from './node'
-export type { Fun, Queue, Frame }
+import type { Queue, Frame } from 'refr'
+import type { Vec4, Void } from './node'
 
 export type GL = EventState<{
         /**
@@ -21,13 +20,13 @@ export type GL = EventState<{
         particles: 64 | 256 | 576 | 1024 | 1600 | 2304 | 3136 | 4096 | 4096 | 5184 | 6400 // (8k)^2
         el: HTMLCanvasElement
         vs?: string | Vec4
-        cs?: string | Vec4
+        cs?: string | Void
         fs?: string | Vec4
         vert?: string | Vec4
-        comp?: string | Vec4
+        comp?: string | Void
         frag?: string | Vec4
         vertex?: string | Vec4
-        compute?: string | Vec4
+        compute?: string | Void
         fragment?: string | Vec4
 
         /**
@@ -55,7 +54,6 @@ export type GL = EventState<{
          */
         _uniform?(key: string, value: Uniform, isMatrix?: boolean): GL
         uniform(key: string, value: Uniform, isMatrix?: boolean): GL
-        uniform(node: NodeProxy): GL
         uniform(target: { [key: string]: Uniform }): GL
         _texture?(key: string, value: string): GL
         texture(key: string, value: string): GL

package/src/utils/pipeline.ts

@@ -118,12 +118,12 @@ export const createPipeline = (
 ) => {
         return device.createRenderPipeline({
                 vertex: {
-                        module: device.createShaderModule({ label: 'vert', code: vs }),
+                        module: device.createShaderModule({ label: 'vert', code: vs.trim() }),
                         entryPoint: 'main',
                         buffers: bufferLayouts,
                 },
                 fragment: {
-                        module: device.createShaderModule({ label: 'frag', code: fs }),
+                        module: device.createShaderModule({ label: 'frag', code: fs.trim() }),
                         entryPoint: 'main',
                         targets: [{ format }],
                 },
@@ -140,7 +140,7 @@ export const createPipeline = (
 export const createComputePipeline = (device: GPUDevice, bindGroupLayouts: GPUBindGroupLayout[], cs: string) => {
         return device.createComputePipeline({
                 compute: {
-                        module: device.createShaderModule({ label: 'compute', code: cs }),
+                        module: device.createShaderModule({ label: 'compute', code: cs.trim() }),
                         entryPoint: 'main',
                 },
                 layout: device.createPipelineLayout({ bindGroupLayouts }),

package/src/utils/program.ts

@@ -9,7 +9,7 @@ const createShader = (c: WebGLRenderingContext, source: string, type: number, on
         if (c.getShaderParameter(shader, c.COMPILE_STATUS)) return shader
         const error = c.getShaderInfoLog(shader)
         c.deleteShader(shader)
-        onError(`Could not compile shader: ${error}`)
+        onError(`Could not compile shader: ${error}\n\n↓↓↓generated↓↓↓\n${source}`)
 }
 
 export const createProgram = (c: WebGLRenderingContext, frag: string, vert: string, gl: GL) => {
@@ -72,7 +72,12 @@ export const createUniform = (c: WebGLRenderingContext, loc: WebGLUniformLocatio
         c[`uniformMatrix${l as 2}fv`](loc, false, value)
 }
 
-export const createTexture = (c: WebGLRenderingContext, img: HTMLImageElement, loc: any, unit: number) => {
+export const createTexture = (
+        c: WebGLRenderingContext,
+        img: HTMLImageElement,
+        loc: WebGLUniformLocation,
+        unit: number
+) => {
         const texture = c.createTexture()
         c.bindTexture(c.TEXTURE_2D, texture)
         c.texImage2D(c.TEXTURE_2D, 0, c.RGBA, c.RGBA, c.UNSIGNED_BYTE, img)

package/src/{webgl.ts → utils/webgl.ts}

@@ -1,5 +1,5 @@
 import { nested as cached } from 'reev'
-import { loadingImage } from './utils/helpers'
+import { is, loadingImage } from './helpers'
 import {
         cleanStorage,
         createAttachment,
@@ -8,17 +8,26 @@ import {
         createStorage,
         createTexture,
         createUniform,
-} from './utils/program'
-import { compute, fragment, vertex } from './node'
-import type { GL, WebGLState } from './types'
+} from './program'
+import type { GL, WebGLState } from '../types'
 
-const vert = /* cpp */ `
+const DEFAULT_FRAGMENT = /* cpp */ `
 #version 300 es
+precision mediump float;
+out vec4 fragColor;
+uniform vec2 iResolution;
 void main() {
-        float x = float(gl_VertexID % 2) * 4.0 - 1.0;
-        float y = float(gl_VertexID / 2) * 4.0 - 1.0;
-        gl_Position = vec4(x, y, 0.0, 1.0);
-}`.trim()
+  fragColor = vec4(fract((gl_FragCoord.xy / iResolution)), 0.0, 1.0);
+}
+`
+
+const DEFAULT_VERTEX = /* cpp */ `
+#version 300 es
+void main() {
+  float x = float(gl_VertexID % 2) * 4.0 - 1.0;
+  float y = float(gl_VertexID / 2) * 4.0 - 1.0;
+  gl_Position = vec4(x, y, 0.0, 1.0);
+}`
 
 const computeProgram = (gl: GL, c: WebGL2RenderingContext) => {
         if (!gl.cs) return null // ignore if no compute shader
@@ -28,9 +37,8 @@ const computeProgram = (gl: GL, c: WebGL2RenderingContext) => {
         let currentNum = 0 // for storage buffers
 
         const units = cached(() => activeUnit++)
-        const config = { isWebGL: true, gl, units }
-
-        const pg = createProgram(c, compute(gl.cs, config), vert, gl)!
+        const cs = is.str(gl.cs) ? gl.cs : gl.cs!.compute({ isWebGL: true, gl, units })
+        const pg = createProgram(c, cs, DEFAULT_VERTEX, gl)!
         const size = Math.ceil(Math.sqrt(gl.particles))
 
         const uniforms = cached((key) => c.getUniformLocation(pg, key)!)
@@ -75,7 +83,9 @@ export const webgl = async (gl: GL) => {
         const config = { isWebGL: true, gl }
         const c = gl.el!.getContext('webgl2')!
         const cp = computeProgram(gl, c)
-        const pg = createProgram(c, fragment(gl.fs, config), vertex(gl.vs, config), gl)!
+        const fs = gl.fs ? (is.str(gl.fs) ? gl.fs : gl.fs!.fragment(config)) : DEFAULT_FRAGMENT
+        const vs = gl.vs ? (is.str(gl.vs) ? gl.vs : gl.vs!.vertex(config)) : DEFAULT_VERTEX
+        const pg = createProgram(c, fs, vs, gl)!
         c.useProgram(pg)
 
         let activeUnit = 0 // for texture units
@@ -98,7 +108,7 @@ export const webgl = async (gl: GL) => {
         const _texture = (key: string, src: string) => {
                 c.useProgram(pg)
                 loadingImage(gl, src, (source) => {
-                        createTexture(c, source, uniforms(key), units(key))
+                        createTexture(c, source, uniforms(key)!, units(key))
                 })
         }
 

package/src/{webgpu.ts → utils/webgpu.ts}

@@ -1,5 +1,5 @@
 import { nested as cached } from 'reev'
-import { is, loadingImage } from './utils/helpers'
+import { is, loadingImage } from './helpers'
 import {
         createArrayBuffer,
         createBindGroup,
@@ -11,12 +11,33 @@ import {
         createPipeline,
         createTextureSampler,
         createVertexBuffers,
-} from './utils/pipeline'
-import type { GL, WebGPUState } from './types'
-import { compute, fragment, vertex } from './node'
+} from './pipeline'
+import type { GL, WebGPUState } from '../types'
 
 const WORKING_GROUP_SIZE = 32
 
+const DEFAULT_VERTEX = /* rust */ `
+struct In { @builtin(vertex_index) vertex_index: u32 }
+struct Out { @builtin(position) position: vec4f }
+@vertex
+fn main(in: In) -> Out {
+  var out: Out;
+  var x = f32(in.vertex_index % 2) * 4.0 - 1.0;
+  var y = f32(in.vertex_index / 2) * 4.0 - 1.0;
+  out.position = vec4f(x, y, 0.0, 1.0);
+  return out;
+}
+`.trim()
+
+const DEFAULT_FRAGMENT = /* rust */ `
+struct Out { @builtin(position) position: vec4f }
+@group(0) @binding(0) var<uniform> iResolution: vec2f;
+@fragment
+fn main(out: Out) -> @location(0) vec4f {
+  return vec4f(fract((out.position.xy / iResolution)), 0.0, 1.0);
+}
+`
+
 const computeProgram = (gl: GL, device: GPUDevice, bindings: any) => {
         let flush = (_pass: GPUComputePassEncoder) => {}
 
@@ -129,9 +150,9 @@ export const webgpu = async (gl: GL) => {
         const render = () => {
                 if (!frag || !vert) {
                         const config = { isWebGL: false, gl }
-                        frag = fragment(gl.fs, config) // needs to be before vertex
-                        vert = vertex(gl.vs, config)
-                        comp = compute(gl.cs, config)
+                        frag = gl.fs ? (is.str(gl.fs) ? gl.fs : gl.fs.fragment(config)) : DEFAULT_FRAGMENT
+                        vert = gl.vs ? (is.str(gl.vs) ? gl.vs : gl.vs.vertex(config)) : DEFAULT_VERTEX
+                        comp = gl.cs ? (is.str(gl.cs) ? gl.cs : gl.cs.compute(config)) : ''
                 }
                 if (gl.loading) return // MEMO: loading after build node
                 if (needsUpdate) update()

package/src/node/node.ts

@@ -1,64 +0,0 @@
-import { code, getConstant, isConversion, isFunction, isOperator, getId, isArrayAccess } from './utils'
-import { assign, toVar } from './scope'
-import { is } from '../utils/helpers'
-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, null)
-}
-
-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, y: string | Symbol) => {
-                if (y === 'type') return type
-                if (y === 'props') return props
-                if (y === 'toVar') return toVar.bind(null, x)
-                if (y === 'isProxy') return true
-                if (y === 'toString') return code.bind(null, x)
-                if (y === Symbol.toPrimitive) return toPrimitive.bind(null, x)
-                if (y === 'listeners') return listeners
-                if (y === 'attribute') return (id = getId()) => attribute(x, id)
-                if (y === 'constant') return (id = getId()) => constant(x, id)
-                if (y === 'uniform') return (id = getId()) => uniform(x, id)
-                if (y === 'variable') return (id = getId()) => variable(id)
-                if (y === 'builtin') return (id = getId()) => builtin(id)
-                if (y === 'vertexStage') return (id = getId()) => vertexStage(x, id)
-                if (y === 'element') return (z: X) => (type === 'storage' ? gather(x, z) : element(x, z))
-                if (y === 'member') return (z: X) => member(x, z)
-                if (y === 'assign') return assign.bind(null, x, x.type === 'gather')
-                if (isOperator(y)) return (...z: X[]) => operator(y, x, ...z)
-                if (isFunction(y)) return (...z: X[]) => function_(y, x, ...z)
-                if (isConversion(y)) return () => conversion(getConstant(y), x)
-                if (is.str(y)) return isArrayAccess(y) ? element(x, y) : member(x, y)
-        }
-        const set = (_: unknown, y: string, z: X) => {
-                if (y === 'value') listeners.forEach((fun) => fun(z))
-                if (is.str(y)) member(x, y).assign(z)
-                return true
-        }
-        const x = new Proxy({}, { get, set }) as unknown as NodeProxy<T>
-        return 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 storage = <T extends C>(x: X<T>, id = getId()) => node<T>('storage', { 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 with proper typing
-export const member = <T extends C>(x: X, index: X) => node<T>('member', null, x, index)
-export const element = <T extends C>(x: X, index: X) => node<T>('element', null, x, index)
-export const gather = <T extends C>(x: X, index: X) => node<T>('gather', null, x, index)
-export const scatter = <T extends C>(x: X, index: X) => node<T>('scatter', null, x, index)
-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)