glre 0.47.0 → 0.49.1

package/dist/react.d.ts

@@ -29,8 +29,54 @@ declare const TYPE_MAPPING: {
     readonly struct: "struct";
 };
 declare const CONSTANTS: (keyof typeof TYPE_MAPPING)[];
+declare const SWIZZLE_BASE_MAP: {
+    readonly float: "float";
+    readonly vec2: "float";
+    readonly vec3: "float";
+    readonly vec4: "float";
+    readonly int: "int";
+    readonly ivec2: "int";
+    readonly ivec3: "int";
+    readonly ivec4: "int";
+    readonly uint: "uint";
+    readonly uvec2: "uint";
+    readonly uvec3: "uint";
+    readonly uvec4: "uint";
+    readonly bool: "bool";
+    readonly bvec2: "bool";
+    readonly bvec3: "bool";
+    readonly bvec4: "bool";
+};
+declare const SWIZZLE_RESULT_MAP: {
+    float: {
+        readonly 1: "float";
+        readonly 2: "vec2";
+        readonly 3: "vec3";
+        readonly 4: "vec4";
+        readonly 9: "mat3";
+        readonly 16: "mat4";
+    };
+    int: {
+        readonly 1: "int";
+        readonly 2: "ivec2";
+        readonly 3: "ivec3";
+        readonly 4: "ivec4";
+    };
+    uint: {
+        readonly 1: "uint";
+        readonly 2: "uvec2";
+        readonly 3: "uvec3";
+        readonly 4: "uvec4";
+    };
+    bool: {
+        readonly 1: "bool";
+        readonly 2: "bvec2";
+        readonly 3: "bvec3";
+        readonly 4: "bvec4";
+    };
+};
 declare const OPERATORS: {
-    readonly not: "";
+    readonly not: "!";
     readonly add: "+";
     readonly sub: "-";
     readonly mul: "*";
@@ -69,28 +115,6 @@ declare const OPERATOR_TYPE_RULES: readonly [readonly ["float", "vec2", "vec2"],
  */
 declare const FUNCTIONS: readonly [...("texture" | "all" | "any" | "determinant" | "distance" | "dot" | "length" | "lengthSq" | "luminance" | "cross" | "cubeTexture" | "texelFetch" | "textureLod")[], "abs", "acos", "acosh", "asin", "asinh", "atan", "atanh", "ceil", "cos", "cosh", "dFdx", "dFdy", "degrees", "exp", "exp2", "floor", "fract", "fwidth", "inverse", "inverseSqrt", "log", "log2", "negate", "normalize", "oneMinus", "radians", "reciprocal", "round", "sign", "sin", "sinh", "sqrt", "tan", "tanh", "trunc", "saturate", "atan2", "clamp", "max", "min", "mix", "pow", "reflect", "refract", "smoothstep", "step"];
 
-/**
- * binding
- */
-declare const createBinding: () => {
-    uniform: reev.Nested<{
-        group: number;
-        binding: number;
-    }, []>;
-    texture: reev.Nested<{
-        group: number;
-        binding: number;
-    }, []>;
-    storage: reev.Nested<{
-        group: number;
-        binding: number;
-    }, []>;
-    attrib: reev.Nested<{
-        location: number;
-    }, []>;
-};
-type Binding = ReturnType<typeof createBinding>;
-
 type Constants = (typeof CONSTANTS)[number] | 'void';
 type Conversions = (typeof CONVERSIONS)[number];
 type Functions = (typeof FUNCTIONS)[number];
@@ -100,7 +124,7 @@ type Operators = (typeof OPERATOR_KEYS)[number];
  */
 interface FnLayout {
     name: string;
-    type: C | 'auto';
+    type?: C | 'auto';
     inputs?: Array<{
         name: string;
         type: C | 'auto';
@@ -123,7 +147,6 @@ interface NodeProps {
 }
 interface NodeContext {
     gl?: Partial<GL>;
-    binding?: Binding;
     label?: 'vert' | 'frag' | 'compute';
     isWebGL?: boolean;
     units?: any;
@@ -140,6 +163,15 @@ interface NodeContext {
         structStructFields: Map<string, StructFields>;
     };
 }
+/**
+ * swizzle
+ */
+type _SwizzleLength<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;
+type _SwizzleBaseMap = typeof SWIZZLE_BASE_MAP;
+type _SwizzleResultMap = typeof SWIZZLE_RESULT_MAP;
+type _SwizzleBase<T extends C> = T extends keyof _SwizzleBaseMap ? _SwizzleBaseMap[T] : never;
+type _SwizzleResult<T extends C, L extends 1 | 2 | 3 | 4> = _SwizzleResultMap[_SwizzleBase<T>][L];
+type InferSwizzleType<T extends C, S extends string> = _SwizzleLength<S> extends infer L extends 1 | 2 | 3 | 4 ? _SwizzleResult<_SwizzleBase<T>, L> : never;
 /**
  * infer
  */
@@ -150,57 +182,6 @@ type ExtractPairs<T> = T extends readonly [infer L, infer R, string] ? [L, R] |
 type OperatorTypeRules = ExtractPairs<_OperatorTypeRulesMap[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>;
-/**
- * swizzle
- */
-type _SwizzleLength<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;
-type _SwizzleBaseMap = {
-    float: 'float';
-    vec2: 'float';
-    vec3: 'float';
-    vec4: 'float';
-    int: 'int';
-    ivec2: 'int';
-    ivec3: 'int';
-    ivec4: 'int';
-    uint: 'uint';
-    uvec2: 'uint';
-    uvec3: 'uint';
-    uvec4: 'uint';
-    bool: 'bool';
-    bvec2: 'bool';
-    bvec3: 'bool';
-    bvec4: 'bool';
-};
-type _SwizzleResultMap = {
-    float: {
-        1: 'float';
-        2: 'vec2';
-        3: 'vec3';
-        4: 'vec4';
-    };
-    int: {
-        1: 'int';
-        2: 'ivec2';
-        3: 'ivec3';
-        4: 'ivec4';
-    };
-    uint: {
-        1: 'uint';
-        2: 'uvec2';
-        3: 'uvec3';
-        4: 'uvec4';
-    };
-    bool: {
-        1: 'bool';
-        2: 'bvec2';
-        3: 'bvec3';
-        4: 'bvec4';
-    };
-};
-type _SwizzleBase<T extends C> = T extends keyof _SwizzleBaseMap ? _SwizzleBaseMap[T] : never;
-type _SwizzleResult<T extends C, L extends 1 | 2 | 3 | 4> = _SwizzleResultMap[_SwizzleBase<T>][L];
-type InferSwizzleType<T extends C, S extends string> = _SwizzleLength<S> extends infer L extends 1 | 2 | 3 | 4 ? _SwizzleResult<_SwizzleBase<T>, L> : never;
 /**
  * Swizzles
  */
@@ -408,6 +389,28 @@ interface _X<T extends C> {
     step<U extends C>(edge: number | X<U>): X<InferOperator<T, U>>;
 }
 
+/**
+ * binding
+ */
+declare const createBinding: () => {
+    uniform: reev.Nested<{
+        group: number;
+        binding: number;
+    }, []>;
+    texture: reev.Nested<{
+        group: number;
+        binding: number;
+    }, []>;
+    storage: reev.Nested<{
+        group: number;
+        binding: number;
+    }, []>;
+    attrib: reev.Nested<{
+        location: number;
+    }, []>;
+};
+type Binding = ReturnType<typeof createBinding>;
+
 type GL = EventState<{
     /**
      * initial value
@@ -445,7 +448,9 @@ type GL = EventState<{
     gpu: GPUCanvasContext;
     device: GPUDevice;
     format: GPUTextureFormat;
-    encoder: GPUCommandEncoder;
+    passEncoder: GPURenderPassEncoder;
+    commandEncoder: GPUCommandEncoder;
+    depthTexture?: GPUTexture;
     binding: Binding;
     /**
      * core state
@@ -499,10 +504,10 @@ type Storage = number[] | Float32Array;
  * for webgpu
  */
 interface UniformData {
-    array: Float32Array;
-    buffer: GPUBuffer;
     binding: number;
     group: number;
+    array: Float32Array;
+    buffer: GPUBuffer;
 }
 interface TextureData {
     binding: number;

package/dist/solid.d.ts

@@ -29,8 +29,54 @@ declare const TYPE_MAPPING: {
     readonly struct: "struct";
 };
 declare const CONSTANTS: (keyof typeof TYPE_MAPPING)[];
+declare const SWIZZLE_BASE_MAP: {
+    readonly float: "float";
+    readonly vec2: "float";
+    readonly vec3: "float";
+    readonly vec4: "float";
+    readonly int: "int";
+    readonly ivec2: "int";
+    readonly ivec3: "int";
+    readonly ivec4: "int";
+    readonly uint: "uint";
+    readonly uvec2: "uint";
+    readonly uvec3: "uint";
+    readonly uvec4: "uint";
+    readonly bool: "bool";
+    readonly bvec2: "bool";
+    readonly bvec3: "bool";
+    readonly bvec4: "bool";
+};
+declare const SWIZZLE_RESULT_MAP: {
+    float: {
+        readonly 1: "float";
+        readonly 2: "vec2";
+        readonly 3: "vec3";
+        readonly 4: "vec4";
+        readonly 9: "mat3";
+        readonly 16: "mat4";
+    };
+    int: {
+        readonly 1: "int";
+        readonly 2: "ivec2";
+        readonly 3: "ivec3";
+        readonly 4: "ivec4";
+    };
+    uint: {
+        readonly 1: "uint";
+        readonly 2: "uvec2";
+        readonly 3: "uvec3";
+        readonly 4: "uvec4";
+    };
+    bool: {
+        readonly 1: "bool";
+        readonly 2: "bvec2";
+        readonly 3: "bvec3";
+        readonly 4: "bvec4";
+    };
+};
 declare const OPERATORS: {
-    readonly not: "";
+    readonly not: "!";
     readonly add: "+";
     readonly sub: "-";
     readonly mul: "*";
@@ -69,28 +115,6 @@ declare const OPERATOR_TYPE_RULES: readonly [readonly ["float", "vec2", "vec2"],
  */
 declare const FUNCTIONS: readonly [...("texture" | "all" | "any" | "determinant" | "distance" | "dot" | "length" | "lengthSq" | "luminance" | "cross" | "cubeTexture" | "texelFetch" | "textureLod")[], "abs", "acos", "acosh", "asin", "asinh", "atan", "atanh", "ceil", "cos", "cosh", "dFdx", "dFdy", "degrees", "exp", "exp2", "floor", "fract", "fwidth", "inverse", "inverseSqrt", "log", "log2", "negate", "normalize", "oneMinus", "radians", "reciprocal", "round", "sign", "sin", "sinh", "sqrt", "tan", "tanh", "trunc", "saturate", "atan2", "clamp", "max", "min", "mix", "pow", "reflect", "refract", "smoothstep", "step"];
 
-/**
- * binding
- */
-declare const createBinding: () => {
-    uniform: reev.Nested<{
-        group: number;
-        binding: number;
-    }, []>;
-    texture: reev.Nested<{
-        group: number;
-        binding: number;
-    }, []>;
-    storage: reev.Nested<{
-        group: number;
-        binding: number;
-    }, []>;
-    attrib: reev.Nested<{
-        location: number;
-    }, []>;
-};
-type Binding = ReturnType<typeof createBinding>;
-
 type Constants = (typeof CONSTANTS)[number] | 'void';
 type Conversions = (typeof CONVERSIONS)[number];
 type Functions = (typeof FUNCTIONS)[number];
@@ -100,7 +124,7 @@ type Operators = (typeof OPERATOR_KEYS)[number];
  */
 interface FnLayout {
     name: string;
-    type: C | 'auto';
+    type?: C | 'auto';
     inputs?: Array<{
         name: string;
         type: C | 'auto';
@@ -123,7 +147,6 @@ interface NodeProps {
 }
 interface NodeContext {
     gl?: Partial<GL>;
-    binding?: Binding;
     label?: 'vert' | 'frag' | 'compute';
     isWebGL?: boolean;
     units?: any;
@@ -140,6 +163,15 @@ interface NodeContext {
         structStructFields: Map<string, StructFields>;
     };
 }
+/**
+ * swizzle
+ */
+type _SwizzleLength<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;
+type _SwizzleBaseMap = typeof SWIZZLE_BASE_MAP;
+type _SwizzleResultMap = typeof SWIZZLE_RESULT_MAP;
+type _SwizzleBase<T extends C> = T extends keyof _SwizzleBaseMap ? _SwizzleBaseMap[T] : never;
+type _SwizzleResult<T extends C, L extends 1 | 2 | 3 | 4> = _SwizzleResultMap[_SwizzleBase<T>][L];
+type InferSwizzleType<T extends C, S extends string> = _SwizzleLength<S> extends infer L extends 1 | 2 | 3 | 4 ? _SwizzleResult<_SwizzleBase<T>, L> : never;
 /**
  * infer
  */
@@ -150,57 +182,6 @@ type ExtractPairs<T> = T extends readonly [infer L, infer R, string] ? [L, R] |
 type OperatorTypeRules = ExtractPairs<_OperatorTypeRulesMap[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>;
-/**
- * swizzle
- */
-type _SwizzleLength<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;
-type _SwizzleBaseMap = {
-    float: 'float';
-    vec2: 'float';
-    vec3: 'float';
-    vec4: 'float';
-    int: 'int';
-    ivec2: 'int';
-    ivec3: 'int';
-    ivec4: 'int';
-    uint: 'uint';
-    uvec2: 'uint';
-    uvec3: 'uint';
-    uvec4: 'uint';
-    bool: 'bool';
-    bvec2: 'bool';
-    bvec3: 'bool';
-    bvec4: 'bool';
-};
-type _SwizzleResultMap = {
-    float: {
-        1: 'float';
-        2: 'vec2';
-        3: 'vec3';
-        4: 'vec4';
-    };
-    int: {
-        1: 'int';
-        2: 'ivec2';
-        3: 'ivec3';
-        4: 'ivec4';
-    };
-    uint: {
-        1: 'uint';
-        2: 'uvec2';
-        3: 'uvec3';
-        4: 'uvec4';
-    };
-    bool: {
-        1: 'bool';
-        2: 'bvec2';
-        3: 'bvec3';
-        4: 'bvec4';
-    };
-};
-type _SwizzleBase<T extends C> = T extends keyof _SwizzleBaseMap ? _SwizzleBaseMap[T] : never;
-type _SwizzleResult<T extends C, L extends 1 | 2 | 3 | 4> = _SwizzleResultMap[_SwizzleBase<T>][L];
-type InferSwizzleType<T extends C, S extends string> = _SwizzleLength<S> extends infer L extends 1 | 2 | 3 | 4 ? _SwizzleResult<_SwizzleBase<T>, L> : never;
 /**
  * Swizzles
  */
@@ -408,6 +389,28 @@ interface _X<T extends C> {
     step<U extends C>(edge: number | X<U>): X<InferOperator<T, U>>;
 }
 
+/**
+ * binding
+ */
+declare const createBinding: () => {
+    uniform: reev.Nested<{
+        group: number;
+        binding: number;
+    }, []>;
+    texture: reev.Nested<{
+        group: number;
+        binding: number;
+    }, []>;
+    storage: reev.Nested<{
+        group: number;
+        binding: number;
+    }, []>;
+    attrib: reev.Nested<{
+        location: number;
+    }, []>;
+};
+type Binding = ReturnType<typeof createBinding>;
+
 type GL = EventState<{
     /**
      * initial value
@@ -445,7 +448,9 @@ type GL = EventState<{
     gpu: GPUCanvasContext;
     device: GPUDevice;
     format: GPUTextureFormat;
-    encoder: GPUCommandEncoder;
+    passEncoder: GPURenderPassEncoder;
+    commandEncoder: GPUCommandEncoder;
+    depthTexture?: GPUTexture;
     binding: Binding;
     /**
      * core state
@@ -499,10 +504,10 @@ type Storage = number[] | Float32Array;
  * for webgpu
  */
 interface UniformData {
-    array: Float32Array;
-    buffer: GPUBuffer;
     binding: number;
     group: number;
+    array: Float32Array;
+    buffer: GPUBuffer;
 }
 interface TextureData {
     binding: number;

package/package.json

@@ -1,6 +1,6 @@
 {
         "name": "glre",
-        "version": "0.47.0",
+        "version": "0.49.1",
         "author": "tseijp",
         "license": "MIT",
         "private": false,

package/src/helpers.ts

@@ -64,9 +64,9 @@ const calcStride = (arrayLength: number, count = 3) => {
         return -1
 }
 
-export const getStride = (arrayLength: number, count = 1, error = console.warn) => {
+export const getStride = (arrayLength: number, count = 1, error = console.warn, id = '') => {
         const ret = calcStride(arrayLength, count)
-        if (!isValidStride(ret)) error(`glre attribute error: Invalid attribute length ${arrayLength}. Must divide by vertex count (${count}) with valid stride (1,2,3,4,9,16)`)
+        if (!isValidStride(ret)) error(`glre attribute error: Invalid attribute length ${arrayLength}, ${id ? `${id} ` : ' '}must divide by vertex count (${count}) with valid stride (1,2,3,4,9,16)`)
         return ret
 }
 

package/src/index.ts

@@ -54,18 +54,23 @@ export const createGL = (...args: Partial<GL>[]) => {
         gl('mount', async (el: HTMLCanvasElement) => {
                 gl.el = findElement(gl) || el || args.map(findElement).find(Boolean)
                 const isAppend = !gl.el // Check first: canvas may unmount during WebGPU async processing
-                if (isAppend && !gl.isNative) gl.el = document.createElement('canvas')
-                for (const arg of args) {
+                if (isAppend && !gl.isNative) {
+                        gl.el = document.createElement('canvas')
+                        Object.assign(gl.el.style, { top: 0, left: 0, position: 'fixed' })
+                }
+                for (let i = 0; i < args.length; i++) {
+                        const arg = args[i]
                         gl.fs = arg.fs || arg.frag || arg.fragment || undefined
                         gl.cs = arg.cs || arg.comp || arg.compute || undefined
                         gl.vs = arg.vs || arg.vert || arg.vertex || undefined
-                        gl.triangleCount = arg.triangleCount || arg.count || 6
+                        gl.triangleCount = arg.triangleCount || 2
                         gl.instanceCount = arg.instanceCount || 1
                         gl.particleCount = arg.particleCount || 1024
+                        gl.count = arg.count || gl.triangleCount * 3 || 6
                         gl(arg)
                         if (is.bol(arg.isWebGL)) gl.isWebGL = arg.isWebGL || !isWebGPUSupported()
                         if (gl.isWebGL) webgl(gl)
-                        else await webgpu(gl)
+                        else await webgpu(gl, i === args.length - 1)
                         if (arg.mount) arg.mount() // events added in mount phase need explicit call to execute
                 }
                 if (!gl.el || gl.isError) return // stop if error or canvas was unmounted during async

package/src/node/create.ts

@@ -8,9 +8,9 @@ const toPrimitive = (x: Y, hint: string) => {
         if (hint === 'string') return code(x as any, null)
 }
 
-export const create = <T extends C>(type: NodeTypes, props?: NodeProps | null, ...args: Y[]) => {
+export const create = <T extends C>(type: NodeTypes, props?: NodeProps | null, ...children: Y[]) => {
         if (!props) props = {}
-        if (args.length) props.children = args
+        if (children.length) props.children = children
         const listeners = new Set<(value: any) => void>()
         const get = (_: unknown, key: string | Symbol) => {
                 if (key === 'type') return type
@@ -30,20 +30,21 @@ export const create = <T extends C>(type: NodeTypes, props?: NodeProps | null, .
                 if (key === 'variable') return (id = getId()) => variable(id)
                 if (key === 'builtin') return (id = getId()) => builtin(id)
                 if (key === 'vertexStage') return (id = getId()) => vertexStage(x, id)
-                if (key === 'element') return (arg: Y) => (type === 'storage' ? gather(x, arg) : element(x, arg))
-                if (key === 'member') return (arg: Y) => member(x, arg)
+                if (key === 'element') return (y: Y) => (type === 'storage' ? gather(x, y) : element(x, y))
+                if (key === 'member') return (y: Y) => member(x, y)
                 if (key === 'assign') return assign.bind(null, x, x.type === 'gather')
                 if (key === 'select') return select.bind(null, x)
                 if (isOperator(key)) {
-                        return key.endsWith('Assign') ? (...args: Y[]) => addToScope(operator(key, x, ...args)) : (...args: Y[]) => operator(key, x, ...args)
+                        if (key.endsWith('Assign')) return (...y: Y[]) => addToScope(operator(key, x, ...y))
+                        return (...y: Y[]) => operator(key, x, ...y)
                 }
-                if (isFunction(key)) return (...args: Y[]) => function_(key, x, ...args)
+                if (isFunction(key)) return (...y: Y[]) => function_(key, x, ...y)
                 if (isConversion(key)) return () => conversion(getConstant(key), x)
                 if (is.str(key)) return isArrayAccess(key) ? element(x, key) : member(x, key)
         }
-        const set = (_: unknown, key: string, arg: Y) => {
-                if (key === 'value') listeners.forEach((fun) => fun(arg))
-                if (is.str(key)) member(x, key).assign(arg)
+        const set = (_: unknown, key: string, y: Y) => {
+                if (key === 'value') listeners.forEach((fun) => fun(y))
+                if (is.str(key)) member(x, key).assign(y)
                 return true
         }
         const x = new Proxy({}, { get, set }) as unknown as X<T>

package/src/node/scope.ts

@@ -1,23 +1,12 @@
 import { conversion, create } from './create'
-import type {
-        FnLayout,
-        FnType,
-        Constants as C,
-        Int,
-        NodeProps,
-        Struct,
-        StructFactory,
-        StructFields,
-        X,
-        Y,
-} from './types'
 import { getId } from './utils'
+import type { FnLayout, FnType, Constants as C, Int, NodeProps, Struct, StructFactory, StructFields, X, Y } from './types'
 
 let scope: X | null = null
 let define: X | null = null
 
 export const addToScope = <T extends C>(x: X<T>) => {
-        if (!scope) return
+        if (!scope) return x
         if (!scope.props.children) scope.props.children = []
         scope.props.children.push(x)
         if (x.type !== 'return' || !define) return x
@@ -133,8 +122,7 @@ export function Fn<T extends X | Struct | void, Args extends any[]>(fun: (args:
                         else
                                 paramDefs.push({
                                         id: input.name,
-                                        inferFrom:
-                                                input.type === 'auto' ? [args[i]] : [conversion(input.type, args[i])],
+                                        inferFrom: input.type === 'auto' ? [args[i]] : [conversion(input.type, args[i])],
                                 })
                 }
                 for (const props of paramDefs) paramVars.push(create('variable', props))

package/src/node/types.ts

@@ -1,6 +1,5 @@
-import { CONSTANTS, CONVERSIONS, FUNCTIONS, OPERATOR_KEYS, OPERATOR_TYPE_RULES } from './utils/const'
+import { CONSTANTS, CONVERSIONS, FUNCTIONS, OPERATOR_KEYS, OPERATOR_TYPE_RULES, SWIZZLE_BASE_MAP, SWIZZLE_RESULT_MAP } from './utils/const'
 import type { GL } from '../types'
-import type { Binding } from '../webgpu/utils'
 
 export type Constants = (typeof CONSTANTS)[number] | 'void'
 export type Conversions = (typeof CONVERSIONS)[number]
@@ -12,7 +11,7 @@ export type Operators = (typeof OPERATOR_KEYS)[number]
  */
 export interface FnLayout {
         name: string
-        type: C | 'auto'
+        type?: C | 'auto'
         inputs?: Array<{
                 name: string
                 type: C | 'auto'
@@ -81,7 +80,6 @@ export interface NodeProps {
 
 export interface NodeContext {
         gl?: Partial<GL>
-        binding?: Binding
         label?: 'vert' | 'frag' | 'compute'
         isWebGL?: boolean
         units?: any // @TODO FIX
@@ -99,6 +97,24 @@ export interface NodeContext {
         }
 }
 
+/**
+ * swizzle
+ */
+// Optimized string length using direct pattern matching
+// prettier-ignore
+type _SwizzleLength<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 inferSwizzleType
+type _SwizzleBaseMap = typeof SWIZZLE_BASE_MAP
+type _SwizzleResultMap = typeof SWIZZLE_RESULT_MAP
+type _SwizzleBase<T extends C> = T extends keyof _SwizzleBaseMap ? _SwizzleBaseMap[T] : never
+type _SwizzleResult<T extends C, L extends 1 | 2 | 3 | 4> = _SwizzleResultMap[_SwizzleBase<T>][L]
+type InferSwizzleType<T extends C, S extends string> = _SwizzleLength<S> extends infer L extends 1 | 2 | 3 | 4 ? _SwizzleResult<_SwizzleBase<T>, L> : never
+
 /**
  * infer
  */
@@ -132,47 +148,6 @@ type OperatorTypeRules = ExtractPairs<_OperatorTypeRulesMap[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>
 
-/**
- * swizzle
- */
-// Optimized string length using direct pattern matching
-// prettier-ignore
-type _SwizzleLength<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
-
-type _SwizzleBaseMap = {
-        float: 'float'
-        vec2: 'float'
-        vec3: 'float'
-        vec4: 'float'
-        int: 'int'
-        ivec2: 'int'
-        ivec3: 'int'
-        ivec4: 'int'
-        uint: 'uint'
-        uvec2: 'uint'
-        uvec3: 'uint'
-        uvec4: 'uint'
-        bool: 'bool'
-        bvec2: 'bool'
-        bvec3: 'bool'
-        bvec4: 'bool'
-}
-
-type _SwizzleResultMap = {
-        float: { 1: 'float'; 2: 'vec2'; 3: 'vec3'; 4: 'vec4' }
-        int: { 1: 'int'; 2: 'ivec2'; 3: 'ivec3'; 4: 'ivec4' }
-        uint: { 1: 'uint'; 2: 'uvec2'; 3: 'uvec3'; 4: 'uvec4' }
-        bool: { 1: 'bool'; 2: 'bvec2'; 3: 'bvec3'; 4: 'bvec4' }
-}
-
-type _SwizzleBase<T extends C> = T extends keyof _SwizzleBaseMap ? _SwizzleBaseMap[T] : never
-type _SwizzleResult<T extends C, L extends 1 | 2 | 3 | 4> = _SwizzleResultMap[_SwizzleBase<T>][L]
-type InferSwizzleType<T extends C, S extends string> = _SwizzleLength<S> extends infer L extends 1 | 2 | 3 | 4 ? _SwizzleResult<_SwizzleBase<T>, L> : never
-
 /**
  * Swizzles
  */