@aelionsdk/material-compiler 0.1.0-beta.1

package/dist/types.d.ts

@@ -0,0 +1,174 @@
+import type { Diagnostic, JsonObject, JsonValue } from '@aelionsdk/core';
+export type MaterialValueType = 'float' | 'enum' | 'visual-frame';
+export type GraphBinding = {
+    readonly value: JsonValue;
+} | {
+    readonly parameter: string;
+} | {
+    readonly inputPort: string;
+} | {
+    readonly node: string;
+    readonly output: string;
+} | {
+    readonly system: string;
+} | {
+    readonly resource: string;
+};
+export interface MaterialGraphNode extends JsonObject {
+    id: string;
+    type: string;
+    typeVersion: string;
+    inputs: Record<string, GraphBinding>;
+}
+export interface MaterialGraph extends JsonObject {
+    $schema: string;
+    graphVersion: string;
+    nodeSet: string;
+    nodes: MaterialGraphNode[];
+    outputs: Record<string, {
+        readonly node: string;
+        readonly output: string;
+    }>;
+}
+export interface MaterialNodeDefinition {
+    readonly type: string;
+    readonly version: string;
+    readonly inputs: Readonly<Record<string, MaterialValueType>>;
+    readonly outputs: Readonly<Record<string, MaterialValueType>>;
+    readonly estimatedTextureSamples: number;
+    readonly estimatedPasses: number;
+}
+export interface ExecutableMaterialNode {
+    readonly id: string;
+    readonly type: string;
+    readonly typeVersion: string;
+    readonly inputs: Readonly<Record<string, GraphBinding>>;
+}
+export interface MaterialUniformBinding {
+    readonly name: string;
+    readonly type: 'float';
+    readonly source: {
+        readonly kind: 'parameter';
+        readonly id: string;
+    } | {
+        readonly kind: 'system';
+        readonly id: string;
+    };
+}
+export interface WebGl2MaterialProgram {
+    readonly backend: 'webgl2';
+    readonly nodeSet: string;
+    readonly graphHash: string;
+    readonly inputPorts: readonly string[];
+    readonly uniforms: readonly MaterialUniformBinding[];
+    readonly fragmentShader: string;
+    readonly webgpu?: WebGpuMaterialProgram;
+    readonly executionPlan: MaterialExecutionPlan;
+    readonly passes?: readonly WebGl2MaterialPass[];
+}
+export interface WebGl2MaterialPassInput {
+    readonly sampler: string;
+    readonly source: {
+        readonly kind: 'external';
+        readonly port: string;
+    } | {
+        readonly kind: 'pass';
+        readonly passId: string;
+    };
+}
+export interface WebGl2MaterialPass {
+    readonly id: string;
+    readonly inputs: readonly WebGl2MaterialPassInput[];
+    readonly uniforms: readonly MaterialUniformBinding[];
+    readonly fragmentShader: string;
+}
+export interface WebGpuMaterialProgram {
+    readonly backend: 'webgpu';
+    readonly nodeSet: string;
+    readonly graphHash: string;
+    readonly inputPorts: readonly string[];
+    readonly uniforms: readonly MaterialUniformBinding[];
+    readonly shader: string;
+    readonly executionPlan: MaterialExecutionPlan;
+}
+export interface MaterialExecutionPass {
+    readonly id: string;
+    readonly kind: 'draw' | 'blur-horizontal' | 'blur-vertical';
+    readonly nodes: readonly string[];
+    readonly estimatedTextureSamples: number;
+}
+export interface MaterialExecutionPlan {
+    readonly passes: readonly MaterialExecutionPass[];
+    readonly intermediateTextureCount: number;
+}
+export interface MaterialGraphBudget {
+    readonly maxNodes: number;
+    readonly maxDepth: number;
+    readonly maxPasses: number;
+    readonly maxTextureSamples: number;
+}
+export interface CompiledMaterialGraph {
+    readonly nodeSet: string;
+    readonly order: readonly string[];
+    readonly depth: number;
+    readonly estimatedPasses: number;
+    readonly estimatedTextureSamples: number;
+    readonly executableNodes: readonly ExecutableMaterialNode[];
+    readonly diagnostics: readonly Diagnostic[];
+}
+export interface CompileMaterialOptions {
+    readonly parameters: Readonly<Record<string, MaterialValueType>>;
+    /** Values for parameters whose Definition declares `affects: specialization`. */
+    readonly specializationValues?: Readonly<Record<string, JsonValue>>;
+    readonly inputPorts: Readonly<Record<string, MaterialValueType>>;
+    readonly systems?: Readonly<Record<string, MaterialValueType>>;
+    readonly budget?: Partial<MaterialGraphBudget>;
+}
+export interface MaterialParameterDefinition {
+    readonly id: string;
+    readonly type: 'boolean' | 'integer' | 'float' | 'enum' | 'string';
+    readonly default: JsonValue;
+    readonly range?: {
+        readonly min?: number;
+        readonly max?: number;
+    };
+    readonly values?: readonly string[];
+    readonly animatable: boolean;
+}
+export interface MaterialPortDefinition {
+    readonly id: string;
+    readonly direction: 'input' | 'output';
+    readonly type: 'visual-frame' | 'mask' | 'depth' | 'motion-vectors';
+    readonly binding: 'host' | 'instance';
+    readonly required: boolean;
+}
+export interface MaterialResourceSlotDefinition {
+    readonly id: string;
+    readonly required: boolean;
+    readonly fallbackResourceId?: string;
+}
+export type MaterialImplementationDescriptor = {
+    readonly type: 'graph';
+} | {
+    readonly type: 'shader';
+    readonly backend: 'webgpu' | 'webgl2';
+} | {
+    readonly type: 'wasm';
+};
+export interface RuntimeMaterialDefinition {
+    readonly parameters: readonly MaterialParameterDefinition[];
+    readonly ports: readonly MaterialPortDefinition[];
+    readonly resourceSlots: readonly MaterialResourceSlotDefinition[];
+    readonly implementations: readonly MaterialImplementationDescriptor[];
+}
+export interface MaterialInstanceValue {
+    readonly parameters: Readonly<Record<string, JsonValue>>;
+    readonly resourceBindings?: Readonly<Record<string, JsonValue>>;
+    readonly inputBindings?: Readonly<Record<string, JsonValue>>;
+}
+export interface MaterialRuntimeSelectionOptions {
+    readonly backend: 'webgpu' | 'webgl2' | 'cpu';
+    readonly trust: 'declarative' | 'trusted-code';
+    readonly trustedCodeAuthorized?: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAEzE,MAAM,MAAM,iBAAiB,GAAG,OAAO,GAAG,MAAM,GAAG,cAAc,CAAC;AAElE,MAAM,MAAM,YAAY,GACpB;IAAE,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAA;CAAE,GAC7B;IAAE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GAC9B;IAAE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GAC9B;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAClD;IAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAC3B;IAAE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC;AAElC,MAAM,WAAW,iBAAkB,SAAQ,UAAU;IACnD,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;CACtC;AAED,MAAM,WAAW,aAAc,SAAQ,UAAU;IAC/C,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,iBAAiB,EAAE,CAAC;IAC3B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAC7E;AAED,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC,CAAC;IAC7D,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC,CAAC;IAC9D,QAAQ,CAAC,uBAAuB,EAAE,MAAM,CAAC;IACzC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;CAClC;AAED,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC;CACzD;AAED,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,MAAM,EACX;QAAE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;QAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;KAAE,GACnD;QAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;QAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC;CACtD;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC,QAAQ,CAAC,QAAQ,EAAE,SAAS,sBAAsB,EAAE,CAAC;IACrD,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,MAAM,CAAC,EAAE,qBAAqB,CAAC;IACxC,QAAQ,CAAC,aAAa,EAAE,qBAAqB,CAAC;IAC9C,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,kBAAkB,EAAE,CAAC;CACjD;AAED,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,MAAM,EACX;QAAE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;QAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;KAAE,GACpD;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;CACxD;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,MAAM,EAAE,SAAS,uBAAuB,EAAE,CAAC;IACpD,QAAQ,CAAC,QAAQ,EAAE,SAAS,sBAAsB,EAAE,CAAC;IACrD,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;CACjC;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC,QAAQ,CAAC,QAAQ,EAAE,SAAS,sBAAsB,EAAE,CAAC;IACrD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,aAAa,EAAE,qBAAqB,CAAC;CAC/C;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,iBAAiB,GAAG,eAAe,CAAC;IAC5D,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,uBAAuB,EAAE,MAAM,CAAC;CAC1C;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,MAAM,EAAE,SAAS,qBAAqB,EAAE,CAAC;IAClD,QAAQ,CAAC,wBAAwB,EAAE,MAAM,CAAC;CAC3C;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;CACpC;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,uBAAuB,EAAE,MAAM,CAAC;IACzC,QAAQ,CAAC,eAAe,EAAE,SAAS,sBAAsB,EAAE,CAAC;IAC5D,QAAQ,CAAC,WAAW,EAAE,SAAS,UAAU,EAAE,CAAC;CAC7C;AAED,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC,CAAC;IACjE,iFAAiF;IACjF,QAAQ,CAAC,oBAAoB,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC;IACpE,QAAQ,CAAC,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC,CAAC;IACjE,QAAQ,CAAC,OAAO,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC,CAAC;IAC/D,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,mBAAmB,CAAC,CAAC;CAChD;AAED,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,SAAS,GAAG,SAAS,GAAG,OAAO,GAAG,MAAM,GAAG,QAAQ,CAAC;IACnE,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAC;IAC5B,QAAQ,CAAC,KAAK,CAAC,EAAE;QAAE,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAClE,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;CAC9B;AAED,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,SAAS,EAAE,OAAO,GAAG,QAAQ,CAAC;IACvC,QAAQ,CAAC,IAAI,EAAE,cAAc,GAAG,MAAM,GAAG,OAAO,GAAG,gBAAgB,CAAC;IACpE,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU,CAAC;IACtC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;CAC5B;AAED,MAAM,WAAW,8BAA8B;IAC7C,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,kBAAkB,CAAC,EAAE,MAAM,CAAC;CACtC;AAED,MAAM,MAAM,gCAAgC,GACxC;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;CAAE,GAC1B;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,QAAQ,GAAG,QAAQ,CAAA;CAAE,GAClE;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAE9B,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,UAAU,EAAE,SAAS,2BAA2B,EAAE,CAAC;IAC5D,QAAQ,CAAC,KAAK,EAAE,SAAS,sBAAsB,EAAE,CAAC;IAClD,QAAQ,CAAC,aAAa,EAAE,SAAS,8BAA8B,EAAE,CAAC;IAClE,QAAQ,CAAC,eAAe,EAAE,SAAS,gCAAgC,EAAE,CAAC;CACvE;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC;IACzD,QAAQ,CAAC,gBAAgB,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC;IAChE,QAAQ,CAAC,aAAa,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC;CAC9D;AAED,MAAM,WAAW,+BAA+B;IAC9C,QAAQ,CAAC,OAAO,EAAE,QAAQ,GAAG,QAAQ,GAAG,KAAK,CAAC;IAC9C,QAAQ,CAAC,KAAK,EAAE,aAAa,GAAG,cAAc,CAAC;IAC/C,QAAQ,CAAC,qBAAqB,CAAC,EAAE,OAAO,CAAC;CAC1C"}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/webgl2.d.ts

@@ -0,0 +1,3 @@
+import type { CompileMaterialOptions, MaterialGraph, WebGl2MaterialProgram } from './types.js';
+export declare function compileMaterialGraphToWebGl2(graph: MaterialGraph, options: CompileMaterialOptions): WebGl2MaterialProgram;
+//# sourceMappingURL=webgl2.d.ts.map

package/dist/webgl2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webgl2.d.ts","sourceRoot":"","sources":["../src/webgl2.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,sBAAsB,EAEtB,aAAa,EAEb,qBAAqB,EAEtB,MAAM,YAAY,CAAC;AAySpB,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,aAAa,EACpB,OAAO,EAAE,sBAAsB,GAC9B,qBAAqB,CA+FvB"}

package/dist/webgl2.js

@@ -0,0 +1,366 @@
+import { buildMaterialExecutionPlan, compileMaterialGraph } from './compiler.js';
+import { compileMaterialGraphToWebGpu } from './webgpu.js';
+function identifier(value) {
+    return value.replaceAll(/[^a-zA-Z0-9_]/gu, '_');
+}
+function literal(value) {
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+        throw new TypeError('WebGL2 material expressions only support finite numeric literals');
+    }
+    return Number.isInteger(value) ? `${value.toString()}.0` : value.toString();
+}
+function graphHash(graph) {
+    const serialized = JSON.stringify(graph);
+    let hash = 2_166_136_261;
+    for (let index = 0; index < serialized.length; index += 1) {
+        hash ^= serialized.charCodeAt(index);
+        hash = Math.imul(hash, 16_777_619);
+    }
+    return (hash >>> 0).toString(16).padStart(8, '0');
+}
+function uniformFor(binding, uniforms) {
+    if ('parameter' in binding) {
+        const name = `u_parameter_${identifier(binding.parameter)}`;
+        uniforms.set(name, {
+            name,
+            type: 'float',
+            source: { kind: 'parameter', id: binding.parameter },
+        });
+        return name;
+    }
+    if ('system' in binding) {
+        const name = `u_system_${identifier(binding.system)}`;
+        uniforms.set(name, { name, type: 'float', source: { kind: 'system', id: binding.system } });
+        return name;
+    }
+    return undefined;
+}
+function bindingExpression(binding, nodeExpressions, inputPorts, uniforms) {
+    if ('value' in binding)
+        return literal(binding.value);
+    const uniform = uniformFor(binding, uniforms);
+    if (uniform !== undefined)
+        return uniform;
+    if ('inputPort' in binding) {
+        inputPorts.add(binding.inputPort);
+        return `texture(u_input_${identifier(binding.inputPort)}, v_uv)`;
+    }
+    if ('node' in binding) {
+        const expression = nodeExpressions.get(binding.node);
+        if (expression === undefined)
+            throw new TypeError(`Node ${binding.node} has no expression`);
+        return expression;
+    }
+    throw new TypeError('Resource bindings are not executable in the Phase 0 WebGL2 backend');
+}
+function nodeExpression(type, input, binding, options) {
+    switch (type) {
+        case 'time.transition-curve': {
+            const curveBinding = binding('curve');
+            const curve = 'value' in curveBinding
+                ? curveBinding.value
+                : 'parameter' in curveBinding
+                    ? options.specializationValues?.[curveBinding.parameter]
+                    : undefined;
+            if (curve === 'linear')
+                return `clamp(${input('progress')}, 0.0, 1.0)`;
+            if (curve === 'smooth') {
+                return `smoothstep(0.0, 1.0, clamp(${input('progress')}, 0.0, 1.0))`;
+            }
+            throw new TypeError('time.transition-curve requires a linear or smooth specialization value');
+        }
+        case 'composite.mix':
+            return `mix(${input('a')}, ${input('b')}, clamp(${input('amount')}, 0.0, 1.0))`;
+        case 'color.temperature':
+            return `aelion_temperature(${input('source')}, ${input('amount')})`;
+        case 'color.lift-black':
+            return `aelion_lift_black(${input('source')}, ${input('amount')})`;
+        case 'color.scale-rgb':
+            return `aelion_scale_rgb(${input('source')}, ${input('scale')})`;
+        case 'composite.screen':
+            return `aelion_screen(${input('base')}, ${input('overlay')})`;
+        case 'math.add':
+            return `(${input('a')} + ${input('b')})`;
+        case 'math.subtract':
+            return `(${input('a')} - ${input('b')})`;
+        case 'math.multiply':
+            return `(${input('a')} * ${input('b')})`;
+        case 'math.divide':
+            return `(${input('a')} / ${input('b')})`;
+        case 'math.clamp':
+            return `clamp(${input('value')}, ${input('min')}, ${input('max')})`;
+        case 'math.smoothstep':
+            return `smoothstep(${input('edge0')}, ${input('edge1')}, ${input('x')})`;
+        case 'color.exposure':
+            return `aelion_scale_rgb(${input('source')}, exp2(${input('stops')}))`;
+        case 'color.contrast':
+            return `aelion_contrast(${input('source')}, ${input('amount')})`;
+        case 'color.saturation':
+            return `aelion_saturation(${input('source')}, ${input('amount')})`;
+        case 'color.invert':
+            return `aelion_invert(${input('source')})`;
+        case 'composite.multiply':
+            return `aelion_multiply(${input('base')}, ${input('overlay')})`;
+        case 'composite.add':
+            return `aelion_add(${input('base')}, ${input('overlay')})`;
+        default:
+            throw new TypeError(`Node ${type} is not supported by the Phase 0 WebGL2 backend`);
+    }
+}
+const HELPERS = `
+vec4 aelion_temperature(vec4 color, float amount) {
+  vec3 scale = vec3(1.0 + amount, 1.0 + amount * 0.15, 1.0 - amount * 0.55);
+  return vec4(max(color.rgb * scale, vec3(0.0)), color.a);
+}
+vec4 aelion_lift_black(vec4 color, float amount) {
+  return vec4(mix(color.rgb, vec3(1.0), clamp(amount, 0.0, 1.0)), color.a);
+}
+vec4 aelion_scale_rgb(vec4 color, float scale) {
+  return vec4(max(color.rgb * scale, vec3(0.0)), color.a);
+}
+vec4 aelion_screen(vec4 base, vec4 overlay) {
+  return vec4(1.0 - (1.0 - base.rgb) * (1.0 - overlay.rgb), base.a + overlay.a - base.a * overlay.a);
+}
+vec4 aelion_contrast(vec4 color, float amount) {
+  return vec4((color.rgb - vec3(0.5)) * amount + vec3(0.5), color.a);
+}
+vec4 aelion_saturation(vec4 color, float amount) {
+  float luma = dot(color.rgb, vec3(0.2126, 0.7152, 0.0722));
+  return vec4(mix(vec3(luma), color.rgb, amount), color.a);
+}
+vec4 aelion_invert(vec4 color) { return vec4(color.a - color.rgb, color.a); }
+vec4 aelion_multiply(vec4 base, vec4 overlay) { return vec4(base.rgb * overlay.rgb, base.a * overlay.a); }
+vec4 aelion_add(vec4 base, vec4 overlay) { return min(base + overlay, vec4(1.0)); }
+`;
+function parameterUniform(id) {
+    return {
+        name: `u_parameter_${identifier(id)}`,
+        type: 'float',
+        source: { kind: 'parameter', id },
+    };
+}
+function numericParameter(binding, context) {
+    if (!('parameter' in binding)) {
+        throw new TypeError(`${context} must bind a numeric Material parameter`);
+    }
+    return binding.parameter;
+}
+function inputPort(binding, context) {
+    if (!('inputPort' in binding))
+        throw new TypeError(`${context} must bind a host input port`);
+    return binding.inputPort;
+}
+function nodeReference(binding, expected, context) {
+    if (!('node' in binding) || binding.node !== expected) {
+        throw new TypeError(`${context} must consume node ${expected}`);
+    }
+}
+function softGlowPasses(graph) {
+    const highlight = graph.nodes.find(node => node.type === 'color.extract-highlights');
+    const blur = graph.nodes.find(node => node.type === 'blur.gaussian');
+    const scale = graph.nodes.find(node => node.type === 'color.scale-rgb');
+    const composite = graph.nodes.find(node => node.type === 'composite.screen');
+    const hasMultiPassNode = graph.nodes.some(node => node.type === 'blur.gaussian');
+    if (!hasMultiPassNode)
+        return undefined;
+    if (highlight === undefined ||
+        blur === undefined ||
+        scale === undefined ||
+        composite === undefined) {
+        throw new TypeError('This multi-pass graph is not supported by the Phase 0 WebGL2 planner');
+    }
+    const sourceBinding = highlight.inputs.source;
+    const thresholdBinding = highlight.inputs.threshold;
+    const blurSource = blur.inputs.source;
+    const radiusBinding = blur.inputs.radiusPx;
+    const scaleSource = scale.inputs.source;
+    const intensityBinding = scale.inputs.scale;
+    const compositeBase = composite.inputs.base;
+    const compositeOverlay = composite.inputs.overlay;
+    if (sourceBinding === undefined ||
+        thresholdBinding === undefined ||
+        blurSource === undefined ||
+        radiusBinding === undefined ||
+        scaleSource === undefined ||
+        intensityBinding === undefined ||
+        compositeBase === undefined ||
+        compositeOverlay === undefined) {
+        throw new TypeError('Soft Glow graph is missing a required binding');
+    }
+    const source = inputPort(sourceBinding, 'Highlight source');
+    const base = inputPort(compositeBase, 'Composite base');
+    if (source !== base)
+        throw new TypeError('Soft Glow source and composite base must match');
+    nodeReference(blurSource, highlight.id, 'Blur source');
+    nodeReference(scaleSource, blur.id, 'Glow scale source');
+    nodeReference(compositeOverlay, scale.id, 'Composite overlay');
+    const threshold = numericParameter(thresholdBinding, 'Highlight threshold');
+    const radius = numericParameter(radiusBinding, 'Blur radius');
+    const intensity = numericParameter(intensityBinding, 'Glow intensity');
+    const thresholdUniform = parameterUniform(threshold);
+    const radiusUniform = parameterUniform(radius);
+    const intensityUniform = parameterUniform(intensity);
+    const preamble = `#version 300 es
+precision highp float;
+in vec2 v_uv;
+out vec4 out_color;`;
+    const blurBody = (axis) => `${preamble}
+uniform sampler2D u_input_source;
+uniform float ${radiusUniform.name};
+void main() {
+  vec2 texel = 1.0 / vec2(textureSize(u_input_source, 0));
+  float radius = clamp(${radiusUniform.name}, 0.0, 64.0);
+  vec2 stepUv = texel * vec2(${axis === 'x' ? 'radius / 4.0, 0.0' : '0.0, radius / 4.0'});
+  vec4 color = texture(u_input_source, v_uv) * 0.227027;
+  color += texture(u_input_source, v_uv + stepUv) * 0.1945946;
+  color += texture(u_input_source, v_uv - stepUv) * 0.1945946;
+  color += texture(u_input_source, v_uv + stepUv * 2.0) * 0.1216216;
+  color += texture(u_input_source, v_uv - stepUv * 2.0) * 0.1216216;
+  color += texture(u_input_source, v_uv + stepUv * 3.0) * 0.054054;
+  color += texture(u_input_source, v_uv - stepUv * 3.0) * 0.054054;
+  color += texture(u_input_source, v_uv + stepUv * 4.0) * 0.016216;
+  color += texture(u_input_source, v_uv - stepUv * 4.0) * 0.016216;
+  out_color = color;
+}`;
+    return [
+        {
+            id: `${highlight.id}:draw`,
+            inputs: [{ sampler: 'source', source: { kind: 'external', port: source } }],
+            uniforms: [thresholdUniform],
+            fragmentShader: `${preamble}
+uniform sampler2D u_input_source;
+uniform float ${thresholdUniform.name};
+void main() {
+  vec4 color = texture(u_input_source, v_uv);
+  float luma = dot(color.rgb, vec3(0.2126, 0.7152, 0.0722));
+  float threshold = clamp(${thresholdUniform.name}, 0.0, 1.0);
+  float gate = smoothstep(max(0.0, threshold - 0.05), min(1.0, threshold + 0.05), luma);
+  out_color = vec4(color.rgb * gate, color.a * gate);
+}`,
+        },
+        {
+            id: `${blur.id}:horizontal`,
+            inputs: [{ sampler: 'source', source: { kind: 'pass', passId: `${highlight.id}:draw` } }],
+            uniforms: [radiusUniform],
+            fragmentShader: blurBody('x'),
+        },
+        {
+            id: `${blur.id}:vertical`,
+            inputs: [{ sampler: 'source', source: { kind: 'pass', passId: `${blur.id}:horizontal` } }],
+            uniforms: [radiusUniform],
+            fragmentShader: blurBody('y'),
+        },
+        {
+            id: `${composite.id}:draw`,
+            inputs: [
+                { sampler: 'base', source: { kind: 'external', port: base } },
+                { sampler: 'overlay', source: { kind: 'pass', passId: `${blur.id}:vertical` } },
+            ],
+            uniforms: [intensityUniform],
+            fragmentShader: `${preamble}
+uniform sampler2D u_input_base;
+uniform sampler2D u_input_overlay;
+uniform float ${intensityUniform.name};
+void main() {
+  vec4 baseColor = texture(u_input_base, v_uv);
+  vec4 glow = texture(u_input_overlay, v_uv) * max(0.0, ${intensityUniform.name});
+  out_color = vec4(
+    1.0 - (1.0 - baseColor.rgb) * (1.0 - glow.rgb),
+    baseColor.a + glow.a - baseColor.a * glow.a
+  );
+}`,
+        },
+    ];
+}
+export function compileMaterialGraphToWebGl2(graph, options) {
+    const analysis = compileMaterialGraph(graph, options);
+    const errors = analysis.diagnostics.filter(value => value.severity === 'error');
+    if (errors.length > 0) {
+        throw new TypeError(`Material graph is not executable: ${errors.map(value => value.code).join(', ')}`);
+    }
+    const multiPasses = softGlowPasses(graph);
+    if (multiPasses !== undefined) {
+        const inputPorts = [
+            ...new Set(multiPasses.flatMap(pass => pass.inputs.flatMap(input => input.source.kind === 'external' ? [input.source.port] : []))),
+        ];
+        const uniforms = [
+            ...new Map(multiPasses.flatMap(pass => pass.uniforms).map(value => [value.name, value])).values(),
+        ];
+        const compiledHash = graphHash(graph);
+        return {
+            backend: 'webgl2',
+            nodeSet: graph.nodeSet,
+            graphHash: compiledHash,
+            inputPorts,
+            uniforms,
+            fragmentShader: multiPasses.at(-1)?.fragmentShader ?? '',
+            executionPlan: buildMaterialExecutionPlan(graph, analysis),
+            passes: multiPasses,
+        };
+    }
+    const nodes = new Map(graph.nodes.map(node => [node.id, node]));
+    const expressions = new Map();
+    const inputPorts = new Set();
+    const uniforms = new Map();
+    for (const id of analysis.order) {
+        const node = nodes.get(id);
+        if (node === undefined)
+            continue;
+        const input = (name) => {
+            const binding = node.inputs[name];
+            if (binding === undefined)
+                throw new TypeError(`Node ${node.id} is missing ${name}`);
+            return bindingExpression(binding, expressions, inputPorts, uniforms);
+        };
+        const binding = (name) => {
+            const value = node.inputs[name];
+            if (value === undefined)
+                throw new TypeError(`Node ${node.id} is missing ${name}`);
+            return value;
+        };
+        expressions.set(id, nodeExpression(node.type, input, binding, options));
+    }
+    const output = graph.outputs.result ?? Object.values(graph.outputs)[0];
+    if (output === undefined)
+        throw new TypeError('Material graph has no output');
+    const resultExpression = expressions.get(output.node);
+    if (resultExpression === undefined)
+        throw new TypeError('Material graph output is unavailable');
+    const samplerDeclarations = [...inputPorts]
+        .map(port => `uniform sampler2D u_input_${identifier(port)};`)
+        .join('\n');
+    const uniformDeclarations = [...uniforms.values()]
+        .map(value => `uniform float ${value.name};`)
+        .join('\n');
+    const compiledHash = graphHash({
+        ...graph,
+        ...(options.specializationValues === undefined
+            ? {}
+            : { specializationValues: options.specializationValues }),
+    });
+    let webgpu;
+    try {
+        webgpu = compileMaterialGraphToWebGpu(graph, options);
+    }
+    catch {
+        webgpu = undefined;
+    }
+    return {
+        backend: 'webgl2',
+        nodeSet: graph.nodeSet,
+        graphHash: compiledHash,
+        inputPorts: [...inputPorts],
+        uniforms: [...uniforms.values()],
+        executionPlan: buildMaterialExecutionPlan(graph, analysis),
+        fragmentShader: `#version 300 es
+precision highp float;
+${samplerDeclarations}
+${uniformDeclarations}
+in vec2 v_uv;
+out vec4 out_color;
+${HELPERS}
+void main() { out_color = ${resultExpression}; }
+`,
+        ...(webgpu === undefined ? {} : { webgpu }),
+    };
+}

package/dist/webgpu.d.ts

@@ -0,0 +1,3 @@
+import type { CompileMaterialOptions, MaterialGraph, WebGpuMaterialProgram } from './types.js';
+export declare function compileMaterialGraphToWebGpu(graph: MaterialGraph, options: CompileMaterialOptions): WebGpuMaterialProgram;
+//# sourceMappingURL=webgpu.d.ts.map

package/dist/webgpu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webgpu.d.ts","sourceRoot":"","sources":["../src/webgpu.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,sBAAsB,EAEtB,aAAa,EAEb,qBAAqB,EACtB,MAAM,YAAY,CAAC;AAkJpB,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,aAAa,EACpB,OAAO,EAAE,sBAAsB,GAC9B,qBAAqB,CA0EvB"}