@aelionsdk/material-compiler 0.1.0-beta.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 FoyonaCZY and AelionSDK contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,7 @@
+# @aelionsdk/material-compiler
+
+Aelion Material Protocol graph compiler for WebGL2 and WebGPU
+
+Install with `npm install @aelionsdk/material-compiler@next`.
+
+Version 0.1.0-beta.1 is a prerelease and its API may change before the first stable release. This package is part of [AelionSDK](https://github.com/FoyonaCZY/AelionSDK); see the repository README for supported browsers, examples and deployment requirements.

package/dist/compiler.d.ts

@@ -0,0 +1,10 @@
+import type { Diagnostic } from '@aelionsdk/core';
+import type { CompileMaterialOptions, CompiledMaterialGraph, MaterialGraph, MaterialImplementationDescriptor, MaterialExecutionPlan, MaterialInstanceValue, MaterialRuntimeSelectionOptions, RuntimeMaterialDefinition } from './types.js';
+export declare function compileMaterialGraph(graph: MaterialGraph, options: CompileMaterialOptions): CompiledMaterialGraph;
+export declare function buildMaterialExecutionPlan(graph: MaterialGraph, compiled: CompiledMaterialGraph): MaterialExecutionPlan;
+export declare function validateMaterialInstance(definition: RuntimeMaterialDefinition, instance: MaterialInstanceValue): readonly Diagnostic[];
+export declare function selectMaterialImplementation(definition: RuntimeMaterialDefinition, options: MaterialRuntimeSelectionOptions): {
+    readonly implementation?: MaterialImplementationDescriptor;
+    readonly diagnostics: readonly Diagnostic[];
+};
+//# sourceMappingURL=compiler.d.ts.map

package/dist/compiler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compiler.d.ts","sourceRoot":"","sources":["../src/compiler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAa,MAAM,iBAAiB,CAAC;AAG7D,OAAO,KAAK,EACV,sBAAsB,EACtB,qBAAqB,EAErB,aAAa,EAEb,gCAAgC,EAEhC,qBAAqB,EACrB,qBAAqB,EACrB,+BAA+B,EAC/B,yBAAyB,EAC1B,MAAM,YAAY,CAAC;AAmGpB,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,aAAa,EACpB,OAAO,EAAE,sBAAsB,GAC9B,qBAAqB,CAiKvB;AAED,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,aAAa,EACpB,QAAQ,EAAE,qBAAqB,GAC9B,qBAAqB,CA0CvB;AA2BD,wBAAgB,wBAAwB,CACtC,UAAU,EAAE,yBAAyB,EACrC,QAAQ,EAAE,qBAAqB,GAC9B,SAAS,UAAU,EAAE,CAmGvB;AAED,wBAAgB,4BAA4B,CAC1C,UAAU,EAAE,yBAAyB,EACrC,OAAO,EAAE,+BAA+B,GACvC;IACD,QAAQ,CAAC,cAAc,CAAC,EAAE,gCAAgC,CAAC;IAC3D,QAAQ,CAAC,WAAW,EAAE,SAAS,UAAU,EAAE,CAAC;CAC7C,CAgDA"}

package/dist/compiler.js

@@ -0,0 +1,349 @@
+import { VISUAL_NODE_SET_1 } from './node-registry.js';
+const DEFAULT_BUDGET = {
+    maxNodes: 128,
+    maxDepth: 32,
+    maxPasses: 8,
+    maxTextureSamples: 256,
+};
+function issue(diagnostics, code, message, path) {
+    diagnostics.push({
+        code,
+        severity: 'error',
+        message,
+        path,
+        recoverable: false,
+    });
+}
+function literalType(value) {
+    return typeof value === 'number' ? 'float' : typeof value === 'string' ? 'enum' : undefined;
+}
+function bindingType(binding, options, outputTypes, diagnostics, path) {
+    if ('value' in binding) {
+        const type = literalType(binding.value);
+        if (type === undefined) {
+            issue(diagnostics, 'MATERIAL_GRAPH_LITERAL_TYPE_INVALID', 'Unsupported literal type', path);
+        }
+        return type;
+    }
+    if ('parameter' in binding) {
+        const type = options.parameters[binding.parameter];
+        if (type === undefined) {
+            issue(diagnostics, 'MATERIAL_GRAPH_PARAMETER_MISSING', `Unknown parameter ${binding.parameter}`, path);
+        }
+        return type;
+    }
+    if ('inputPort' in binding) {
+        const type = options.inputPorts[binding.inputPort];
+        if (type === undefined) {
+            issue(diagnostics, 'MATERIAL_GRAPH_PORT_MISSING', `Unknown input port ${binding.inputPort}`, path);
+        }
+        return type;
+    }
+    if ('system' in binding) {
+        const type = (options.systems ?? { transitionProgress: 'float' })[binding.system];
+        if (type === undefined) {
+            issue(diagnostics, 'MATERIAL_GRAPH_SYSTEM_MISSING', `Unknown system value ${binding.system}`, path);
+        }
+        return type;
+    }
+    if ('node' in binding) {
+        const type = outputTypes.get(binding.node)?.[binding.output];
+        if (type === undefined) {
+            issue(diagnostics, 'MATERIAL_GRAPH_OUTPUT_MISSING', `Unknown node output ${binding.node}.${binding.output}`, path);
+        }
+        return type;
+    }
+    issue(diagnostics, 'MATERIAL_GRAPH_RESOURCE_UNTYPED', 'Resource bindings require an explicit typed node', path);
+    return undefined;
+}
+export function compileMaterialGraph(graph, options) {
+    const diagnostics = [];
+    const budget = { ...DEFAULT_BUDGET, ...options.budget };
+    const nodeById = new Map(graph.nodes.map(node => [node.id, node]));
+    if (nodeById.size !== graph.nodes.length) {
+        issue(diagnostics, 'MATERIAL_GRAPH_DUPLICATE_NODE', 'Node IDs must be unique', ['nodes']);
+    }
+    if (graph.nodes.length > budget.maxNodes) {
+        issue(diagnostics, 'MATERIAL_BUDGET_EXCEEDED', `Graph has ${graph.nodes.length} nodes; limit is ${budget.maxNodes}`, ['nodes']);
+    }
+    const visiting = new Set();
+    const visited = new Set();
+    const order = [];
+    const depths = new Map();
+    const visit = (id) => {
+        if (visiting.has(id)) {
+            issue(diagnostics, 'MATERIAL_DEPENDENCY_CYCLE', `Graph cycle includes ${id}`, ['nodes']);
+            return 0;
+        }
+        if (visited.has(id))
+            return depths.get(id) ?? 0;
+        const node = nodeById.get(id);
+        if (node === undefined)
+            return 0;
+        visiting.add(id);
+        let depth = 1;
+        for (const binding of Object.values(node.inputs)) {
+            if ('node' in binding) {
+                if (!nodeById.has(binding.node)) {
+                    issue(diagnostics, 'MATERIAL_GRAPH_NODE_MISSING', `Node ${id} references missing node ${binding.node}`, ['nodes', id, 'inputs']);
+                }
+                else {
+                    depth = Math.max(depth, visit(binding.node) + 1);
+                }
+            }
+        }
+        visiting.delete(id);
+        visited.add(id);
+        depths.set(id, depth);
+        order.push(id);
+        return depth;
+    };
+    graph.nodes.forEach(node => visit(node.id));
+    const depth = Math.max(0, ...depths.values());
+    if (depth > budget.maxDepth) {
+        issue(diagnostics, 'MATERIAL_BUDGET_EXCEEDED', `Graph depth ${depth} exceeds limit ${budget.maxDepth}`, ['nodes']);
+    }
+    const outputTypes = new Map();
+    let estimatedPasses = 0;
+    let estimatedTextureSamples = 0;
+    for (const id of order) {
+        const node = nodeById.get(id);
+        if (node === undefined)
+            continue;
+        const definition = VISUAL_NODE_SET_1.get(`${node.type}@${node.typeVersion}`);
+        if (definition === undefined) {
+            issue(diagnostics, 'MATERIAL_NODE_UNSUPPORTED', `Unsupported node ${node.type}@${node.typeVersion}`, ['nodes', id, 'type']);
+            continue;
+        }
+        for (const [inputName, expectedType] of Object.entries(definition.inputs)) {
+            const binding = node.inputs[inputName];
+            if (binding === undefined) {
+                issue(diagnostics, 'MATERIAL_GRAPH_INPUT_MISSING', `Node ${id} is missing input ${inputName}`, ['nodes', id, 'inputs', inputName]);
+                continue;
+            }
+            const actualType = bindingType(binding, options, outputTypes, diagnostics, [
+                'nodes',
+                id,
+                'inputs',
+                inputName,
+            ]);
+            if (actualType !== undefined && actualType !== expectedType) {
+                issue(diagnostics, 'MATERIAL_GRAPH_TYPE_MISMATCH', `Node ${id} input ${inputName} expects ${expectedType}, received ${actualType}`, ['nodes', id, 'inputs', inputName]);
+            }
+        }
+        for (const inputName of Object.keys(node.inputs)) {
+            if (!(inputName in definition.inputs)) {
+                issue(diagnostics, 'MATERIAL_GRAPH_INPUT_UNKNOWN', `Node ${id} has unknown input ${inputName}`, ['nodes', id, 'inputs', inputName]);
+            }
+        }
+        outputTypes.set(id, definition.outputs);
+        estimatedPasses += definition.estimatedPasses;
+        estimatedTextureSamples += definition.estimatedTextureSamples;
+    }
+    for (const [name, output] of Object.entries(graph.outputs)) {
+        const type = outputTypes.get(output.node)?.[output.output];
+        if (type !== 'visual-frame') {
+            issue(diagnostics, 'MATERIAL_GRAPH_OUTPUT_INVALID', `Graph output ${name} must resolve to visual-frame`, ['outputs', name]);
+        }
+    }
+    if (estimatedPasses > budget.maxPasses || estimatedTextureSamples > budget.maxTextureSamples) {
+        issue(diagnostics, 'MATERIAL_BUDGET_EXCEEDED', 'Graph static execution budget exceeds host limits', ['nodes']);
+    }
+    return {
+        nodeSet: graph.nodeSet,
+        order,
+        depth,
+        estimatedPasses,
+        estimatedTextureSamples,
+        executableNodes: order.flatMap(id => {
+            const node = nodeById.get(id);
+            return node === undefined
+                ? []
+                : [
+                    {
+                        id: node.id,
+                        type: node.type,
+                        typeVersion: node.typeVersion,
+                        inputs: node.inputs,
+                    },
+                ];
+        }),
+        diagnostics,
+    };
+}
+export function buildMaterialExecutionPlan(graph, compiled) {
+    const passes = [];
+    let pendingFusedNodes = [];
+    const flushFused = (ownerId, samples) => {
+        if (pendingFusedNodes.length === 0)
+            return;
+        passes.push({
+            id: `${ownerId}:draw`,
+            kind: 'draw',
+            nodes: pendingFusedNodes,
+            estimatedTextureSamples: Math.max(1, samples),
+        });
+        pendingFusedNodes = [];
+    };
+    for (const id of compiled.order) {
+        const node = graph.nodes.find(value => value.id === id);
+        const definition = node === undefined ? undefined : VISUAL_NODE_SET_1.get(`${node.type}@${node.typeVersion}`);
+        if (node?.type === 'blur.gaussian') {
+            flushFused(id, 1);
+            passes.push({
+                id: `${id}:horizontal`,
+                kind: 'blur-horizontal',
+                nodes: [id],
+                estimatedTextureSamples: 8,
+            }, {
+                id: `${id}:vertical`,
+                kind: 'blur-vertical',
+                nodes: [id],
+                estimatedTextureSamples: 8,
+            });
+            continue;
+        }
+        pendingFusedNodes.push(id);
+        if ((definition?.estimatedPasses ?? 0) > 0) {
+            flushFused(id, definition?.estimatedTextureSamples ?? 1);
+        }
+    }
+    flushFused('output', 1);
+    return { passes, intermediateTextureCount: Math.max(0, passes.length - 1) };
+}
+function runtimeIssue(diagnostics, code, message, path) {
+    issue(diagnostics, code, message, path);
+}
+function staticValue(value) {
+    if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+        const animation = Reflect.get(value, 'animation');
+        if (animation !== null && typeof animation === 'object') {
+            const keyframes = Reflect.get(animation, 'keyframes');
+            if (Array.isArray(keyframes)) {
+                const first = keyframes[0];
+                return first !== null && typeof first === 'object'
+                    ? (Reflect.get(first, 'value') ?? null)
+                    : null;
+            }
+        }
+    }
+    return value;
+}
+export function validateMaterialInstance(definition, instance) {
+    const diagnostics = [];
+    const parameters = new Map(definition.parameters.map(value => [value.id, value]));
+    for (const [id, source] of Object.entries(instance.parameters)) {
+        const parameter = parameters.get(id);
+        if (parameter === undefined) {
+            runtimeIssue(diagnostics, 'MATERIAL_INSTANCE_INVALID', `Unknown parameter ${id}`, [
+                'parameters',
+                id,
+            ]);
+            continue;
+        }
+        const value = staticValue(source);
+        const numeric = parameter.type === 'float' || parameter.type === 'integer';
+        if (numeric && (typeof value !== 'number' || !Number.isFinite(value))) {
+            runtimeIssue(diagnostics, 'MATERIAL_INSTANCE_INVALID', `Parameter ${id} must be finite`, [
+                'parameters',
+                id,
+            ]);
+            continue;
+        }
+        if (parameter.type === 'integer' && !Number.isSafeInteger(value)) {
+            runtimeIssue(diagnostics, 'MATERIAL_INSTANCE_INVALID', `Parameter ${id} must be a safe integer`, ['parameters', id]);
+        }
+        if (parameter.type === 'boolean' && typeof value !== 'boolean') {
+            runtimeIssue(diagnostics, 'MATERIAL_INSTANCE_INVALID', `Parameter ${id} must be boolean`, [
+                'parameters',
+                id,
+            ]);
+        }
+        if ((parameter.type === 'enum' || parameter.type === 'string') && typeof value !== 'string') {
+            runtimeIssue(diagnostics, 'MATERIAL_INSTANCE_INVALID', `Parameter ${id} must be a string`, [
+                'parameters',
+                id,
+            ]);
+        }
+        if (parameter.type === 'enum' &&
+            (typeof value !== 'string' || !parameter.values?.includes(value))) {
+            runtimeIssue(diagnostics, 'MATERIAL_INSTANCE_INVALID', `Parameter ${id} has an invalid enum value`, ['parameters', id]);
+        }
+        if (numeric && typeof value === 'number') {
+            if (parameter.range?.min !== undefined && value < parameter.range.min) {
+                runtimeIssue(diagnostics, 'MATERIAL_PARAMETER_OUT_OF_RANGE', `${id} is below its minimum`, [
+                    'parameters',
+                    id,
+                ]);
+            }
+            if (parameter.range?.max !== undefined && value > parameter.range.max) {
+                runtimeIssue(diagnostics, 'MATERIAL_PARAMETER_OUT_OF_RANGE', `${id} exceeds its maximum`, [
+                    'parameters',
+                    id,
+                ]);
+            }
+        }
+    }
+    const resources = instance.resourceBindings ?? {};
+    for (const slot of definition.resourceSlots) {
+        if (slot.required &&
+            resources[slot.id] === undefined &&
+            slot.fallbackResourceId === undefined) {
+            runtimeIssue(diagnostics, 'MATERIAL_INSTANCE_INVALID', `Required resource ${slot.id} is missing`, ['resourceBindings', slot.id]);
+        }
+    }
+    const inputBindings = instance.inputBindings ?? {};
+    for (const port of definition.ports) {
+        if (port.direction === 'input' &&
+            port.binding === 'instance' &&
+            port.required &&
+            inputBindings[port.id] === undefined) {
+            runtimeIssue(diagnostics, 'MATERIAL_INSTANCE_INVALID', `Required input ${port.id} is missing`, ['inputBindings', port.id]);
+        }
+    }
+    return diagnostics;
+}
+export function selectMaterialImplementation(definition, options) {
+    const executableCode = definition.implementations.some(value => value.type !== 'graph');
+    if (executableCode && options.trust !== 'trusted-code') {
+        return {
+            diagnostics: [
+                {
+                    code: 'MATERIAL_TRUST_REQUIRED',
+                    severity: 'error',
+                    message: 'Shader/WASM Material implementations require a trusted-code package',
+                    recoverable: false,
+                },
+            ],
+        };
+    }
+    if (options.trust === 'trusted-code' &&
+        executableCode &&
+        options.trustedCodeAuthorized !== true) {
+        return {
+            diagnostics: [
+                {
+                    code: 'MATERIAL_TRUST_REQUIRED',
+                    severity: 'error',
+                    message: 'The host did not authorize this trusted-code Material package',
+                    recoverable: false,
+                },
+            ],
+        };
+    }
+    const implementation = definition.implementations.find(value => (value.type === 'graph' && options.backend !== 'cpu') ||
+        (value.type === 'shader' && value.backend === options.backend) ||
+        (value.type === 'wasm' && options.backend === 'cpu'));
+    return implementation === undefined
+        ? {
+            diagnostics: [
+                {
+                    code: 'MATERIAL_BACKEND_UNAVAILABLE',
+                    severity: 'error',
+                    message: `No Material implementation supports ${options.backend}`,
+                    recoverable: true,
+                },
+            ],
+        }
+        : { implementation, diagnostics: [] };
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from './compiler.js';
+export * from './node-registry.js';
+export * from './types.js';
+export * from './webgl2.js';
+export * from './webgpu.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,oBAAoB,CAAC;AACnC,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC"}

package/dist/index.js

@@ -0,0 +1,5 @@
+export * from './compiler.js';
+export * from './node-registry.js';
+export * from './types.js';
+export * from './webgl2.js';
+export * from './webgpu.js';

package/dist/node-registry.d.ts

@@ -0,0 +1,4 @@
+import type { MaterialNodeDefinition } from './types.js';
+export declare const VISUAL_NODE_SET_1: Map<string, MaterialNodeDefinition>;
+export declare const VISUAL_NODE_SET_1_DEFINITIONS: readonly MaterialNodeDefinition[];
+//# sourceMappingURL=node-registry.d.ts.map

package/dist/node-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-registry.d.ts","sourceRoot":"","sources":["../src/node-registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAqKzD,eAAO,MAAM,iBAAiB,qCAE7B,CAAC;AAEF,eAAO,MAAM,6BAA6B,mCAAc,CAAC"}

package/dist/node-registry.js

@@ -0,0 +1,164 @@
+const definitions = [
+    {
+        type: 'time.transition-curve',
+        version: '1.0.0',
+        inputs: { progress: 'float', curve: 'enum' },
+        outputs: { value: 'float' },
+        estimatedTextureSamples: 0,
+        estimatedPasses: 0,
+    },
+    {
+        type: 'composite.mix',
+        version: '1.0.0',
+        inputs: { a: 'visual-frame', b: 'visual-frame', amount: 'float' },
+        outputs: { frame: 'visual-frame' },
+        estimatedTextureSamples: 2,
+        estimatedPasses: 1,
+    },
+    {
+        type: 'color.temperature',
+        version: '1.0.0',
+        inputs: { source: 'visual-frame', amount: 'float' },
+        outputs: { frame: 'visual-frame' },
+        estimatedTextureSamples: 1,
+        estimatedPasses: 0,
+    },
+    {
+        type: 'color.lift-black',
+        version: '1.0.0',
+        inputs: { source: 'visual-frame', amount: 'float' },
+        outputs: { frame: 'visual-frame' },
+        estimatedTextureSamples: 1,
+        estimatedPasses: 0,
+    },
+    {
+        type: 'color.extract-highlights',
+        version: '1.0.0',
+        inputs: { source: 'visual-frame', threshold: 'float' },
+        outputs: { frame: 'visual-frame' },
+        estimatedTextureSamples: 1,
+        estimatedPasses: 1,
+    },
+    {
+        type: 'blur.gaussian',
+        version: '1.0.0',
+        inputs: { source: 'visual-frame', radiusPx: 'float' },
+        outputs: { frame: 'visual-frame' },
+        estimatedTextureSamples: 16,
+        estimatedPasses: 2,
+    },
+    {
+        type: 'color.scale-rgb',
+        version: '1.0.0',
+        inputs: { source: 'visual-frame', scale: 'float' },
+        outputs: { frame: 'visual-frame' },
+        estimatedTextureSamples: 1,
+        estimatedPasses: 0,
+    },
+    {
+        type: 'composite.screen',
+        version: '1.0.0',
+        inputs: { base: 'visual-frame', overlay: 'visual-frame' },
+        outputs: { frame: 'visual-frame' },
+        estimatedTextureSamples: 2,
+        estimatedPasses: 1,
+    },
+    {
+        type: 'math.add',
+        version: '1.0.0',
+        inputs: { a: 'float', b: 'float' },
+        outputs: { value: 'float' },
+        estimatedTextureSamples: 0,
+        estimatedPasses: 0,
+    },
+    {
+        type: 'math.subtract',
+        version: '1.0.0',
+        inputs: { a: 'float', b: 'float' },
+        outputs: { value: 'float' },
+        estimatedTextureSamples: 0,
+        estimatedPasses: 0,
+    },
+    {
+        type: 'math.multiply',
+        version: '1.0.0',
+        inputs: { a: 'float', b: 'float' },
+        outputs: { value: 'float' },
+        estimatedTextureSamples: 0,
+        estimatedPasses: 0,
+    },
+    {
+        type: 'math.divide',
+        version: '1.0.0',
+        inputs: { a: 'float', b: 'float' },
+        outputs: { value: 'float' },
+        estimatedTextureSamples: 0,
+        estimatedPasses: 0,
+    },
+    {
+        type: 'math.clamp',
+        version: '1.0.0',
+        inputs: { value: 'float', min: 'float', max: 'float' },
+        outputs: { value: 'float' },
+        estimatedTextureSamples: 0,
+        estimatedPasses: 0,
+    },
+    {
+        type: 'math.smoothstep',
+        version: '1.0.0',
+        inputs: { edge0: 'float', edge1: 'float', x: 'float' },
+        outputs: { value: 'float' },
+        estimatedTextureSamples: 0,
+        estimatedPasses: 0,
+    },
+    {
+        type: 'color.exposure',
+        version: '1.0.0',
+        inputs: { source: 'visual-frame', stops: 'float' },
+        outputs: { frame: 'visual-frame' },
+        estimatedTextureSamples: 1,
+        estimatedPasses: 0,
+    },
+    {
+        type: 'color.contrast',
+        version: '1.0.0',
+        inputs: { source: 'visual-frame', amount: 'float' },
+        outputs: { frame: 'visual-frame' },
+        estimatedTextureSamples: 1,
+        estimatedPasses: 0,
+    },
+    {
+        type: 'color.saturation',
+        version: '1.0.0',
+        inputs: { source: 'visual-frame', amount: 'float' },
+        outputs: { frame: 'visual-frame' },
+        estimatedTextureSamples: 1,
+        estimatedPasses: 0,
+    },
+    {
+        type: 'color.invert',
+        version: '1.0.0',
+        inputs: { source: 'visual-frame' },
+        outputs: { frame: 'visual-frame' },
+        estimatedTextureSamples: 1,
+        estimatedPasses: 0,
+    },
+    {
+        type: 'composite.multiply',
+        version: '1.0.0',
+        inputs: { base: 'visual-frame', overlay: 'visual-frame' },
+        outputs: { frame: 'visual-frame' },
+        estimatedTextureSamples: 2,
+        estimatedPasses: 1,
+    },
+    {
+        type: 'composite.add',
+        version: '1.0.0',
+        inputs: { base: 'visual-frame', overlay: 'visual-frame' },
+        outputs: { frame: 'visual-frame' },
+        estimatedTextureSamples: 2,
+        estimatedPasses: 1,
+    },
+];
+export const VISUAL_NODE_SET_1 = new Map(definitions.map(definition => [`${definition.type}@${definition.version}`, definition]));
+export const VISUAL_NODE_SET_1_DEFINITIONS = definitions;