@triforge/shader-core 0.1.0

package/dist/core/CompileContext.d.ts

@@ -0,0 +1,60 @@
+import type { ShaderNode } from './ShaderNode.js';
+import type { InputSocket } from './InputSocket.js';
+import type { OutputNode } from './OutputNode.js';
+export interface CompiledMaterial {
+    vertexShader: string;
+    fragmentShader: string;
+    uniforms: Record<string, {
+        value: unknown;
+    }>;
+    nodes: ShaderNode[];
+}
+/**
+ * Walks the node graph from an OutputNode, validates all connections,
+ * deduplicates GLSL function definitions, scopes variable names to node IDs,
+ * and emits a complete vertex + fragment shader pair.
+ *
+ * Three responsibilities:
+ *   1. Topological sort     — correct dependency order
+ *   2. Deduplication        — one function def per node type
+ *   3. Variable authority   — all GLSL variable names owned here
+ */
+export declare class CompileContext {
+    private visited;
+    private visiting;
+    private order;
+    private emittedDefs;
+    private defs;
+    private calls;
+    private graphPath;
+    private _uniforms;
+    /** Collected vertex attribute→varying injections from all nodes. Keyed by varyingName. */
+    private _vertexInjections;
+    compile(outputNode: OutputNode): CompiledMaterial;
+    /**
+     * Returns the GLSL variable name for a node's output socket.
+     * Format: _st_{nodeId}_{socketName}
+     */
+    outputVar(node: ShaderNode, socketName: string): string;
+    /**
+     * Resolves an input socket to a GLSL expression.
+     * If connected → returns the upstream node's output variable name.
+     * If float with uniformName → registers a uniform and returns its name (live, GSAP-driveable).
+     * Otherwise → returns a GLSL literal from the socket's default value.
+     */
+    resolveInput(socket: InputSocket<unknown>): string;
+    private visit;
+    private emit;
+    private emitDefs;
+    private validate;
+    private validateNode;
+    private typesCompatible;
+    private buildVertexShader;
+    private buildUniformDeclarations;
+    private buildFragmentShader;
+    private toLiteral;
+    static hexToRgbArray(hex: string): [number, number, number];
+    static hexToVec3(hex: string): string;
+    private hexToVec3;
+}
+//# sourceMappingURL=CompileContext.d.ts.map

package/dist/core/CompileContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CompileContext.d.ts","sourceRoot":"","sources":["../../src/core/CompileContext.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AACjD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AACnD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAEjD,MAAM,WAAW,gBAAgB;IAC/B,YAAY,EAAI,MAAM,CAAA;IACtB,cAAc,EAAE,MAAM,CAAA;IACtB,QAAQ,EAAQ,MAAM,CAAC,MAAM,EAAE;QAAE,KAAK,EAAE,OAAO,CAAA;KAAE,CAAC,CAAA;IAClD,KAAK,EAAW,UAAU,EAAE,CAAA;CAC7B;AAED;;;;;;;;;GASG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,OAAO,CAAqD;IACpE,OAAO,CAAC,QAAQ,CAAoD;IACpE,OAAO,CAAC,KAAK,CAAgD;IAC7D,OAAO,CAAC,WAAW,CAAiD;IACpE,OAAO,CAAC,IAAI,CAAiD;IAC7D,OAAO,CAAC,KAAK,CAAgD;IAC7D,OAAO,CAAC,SAAS,CAA4C;IAC7D,OAAO,CAAC,SAAS,CAAuD;IACxE,0FAA0F;IAC1F,OAAO,CAAC,iBAAiB,CAAiE;IAI1F,OAAO,CAAC,UAAU,EAAE,UAAU,GAAG,gBAAgB;IAcjD;;;OAGG;IACH,SAAS,CAAC,IAAI,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM;IAKvD;;;;;OAKG;IACH,YAAY,CAAC,MAAM,EAAE,WAAW,CAAC,OAAO,CAAC,GAAG,MAAM;IAuBlD,OAAO,CAAC,KAAK;IA8Bb,OAAO,CAAC,IAAI;IAoBZ,OAAO,CAAC,QAAQ;IA0BhB,OAAO,CAAC,QAAQ;IAKhB,OAAO,CAAC,YAAY;IAsCpB,OAAO,CAAC,eAAe;IASvB,OAAO,CAAC,iBAAiB;IAuBzB,OAAO,CAAC,wBAAwB;IAMhC,OAAO,CAAC,mBAAmB;IA2B3B,OAAO,CAAC,SAAS;IAqBjB,MAAM,CAAC,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC;IAS3D,MAAM,CAAC,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;IAQrC,OAAO,CAAC,SAAS;CAGlB"}

package/dist/core/CompileContext.js

@@ -0,0 +1,276 @@
+import { ShaderNodeError } from './ShaderNodeError.js';
+import { ShaderConfig } from './ShaderConfig.js';
+/**
+ * Walks the node graph from an OutputNode, validates all connections,
+ * deduplicates GLSL function definitions, scopes variable names to node IDs,
+ * and emits a complete vertex + fragment shader pair.
+ *
+ * Three responsibilities:
+ *   1. Topological sort     — correct dependency order
+ *   2. Deduplication        — one function def per node type
+ *   3. Variable authority   — all GLSL variable names owned here
+ */
+export class CompileContext {
+    constructor() {
+        this.visited = new Set();
+        this.visiting = new Set();
+        this.order = [];
+        this.emittedDefs = new Set();
+        this.defs = [];
+        this.calls = [];
+        this.graphPath = [];
+        this._uniforms = {};
+        /** Collected vertex attribute→varying injections from all nodes. Keyed by varyingName. */
+        this._vertexInjections = new Map();
+    }
+    // ── Public API ────────────────────────────────────────────────────
+    compile(outputNode) {
+        this.graphPath = [outputNode.nodeType];
+        this.validate(outputNode);
+        this.visit(outputNode);
+        this.emit();
+        return {
+            vertexShader: this.buildVertexShader(),
+            fragmentShader: this.buildFragmentShader(),
+            uniforms: this._uniforms,
+            nodes: this.order,
+        };
+    }
+    /**
+     * Returns the GLSL variable name for a node's output socket.
+     * Format: _st_{nodeId}_{socketName}
+     */
+    outputVar(node, socketName) {
+        const safe = socketName.replace(/[^a-zA-Z0-9_]/g, '_');
+        return `_st_${node.id}_${safe}`;
+    }
+    /**
+     * Resolves an input socket to a GLSL expression.
+     * If connected → returns the upstream node's output variable name.
+     * If float with uniformName → registers a uniform and returns its name (live, GSAP-driveable).
+     * Otherwise → returns a GLSL literal from the socket's default value.
+     */
+    resolveInput(socket) {
+        if (socket.connection) {
+            return this.outputVar(socket.connection.node, socket.connection.name);
+        }
+        if (socket.uniformName !== null) {
+            if (!(socket.uniformName in this._uniforms)) {
+                if (socket.type === 'color') {
+                    const raw = socket.defaultValue;
+                    const rgb = typeof raw === 'string'
+                        ? CompileContext.hexToRgbArray(raw)
+                        : (Array.isArray(raw) ? raw : [1, 1, 1]);
+                    this._uniforms[socket.uniformName] = { value: rgb };
+                }
+                else {
+                    this._uniforms[socket.uniformName] = { value: socket.defaultValue };
+                }
+            }
+            return socket.uniformName;
+        }
+        return this.toLiteral(socket.defaultValue, socket.type);
+    }
+    // ── Graph walk ────────────────────────────────────────────────────
+    visit(node) {
+        if (this.visited.has(node.id))
+            return;
+        if (this.visiting.has(node.id)) {
+            ShaderNodeError.throw({
+                nodeType: node.nodeType,
+                nodeId: node.id,
+                problem: 'Circular dependency detected. A node cannot depend on itself through its own chain.',
+                fix: 'Node outputs can only flow forward toward MaterialOutput, never back upstream.',
+                graphPath: [...this.graphPath],
+            });
+        }
+        this.visiting.add(node.id);
+        this.graphPath.push(node.nodeType);
+        for (const socket of Object.values(node.getInputSockets())) {
+            if (socket.connection) {
+                this.visit(socket.connection.node);
+            }
+        }
+        this.graphPath.pop();
+        this.visiting.delete(node.id);
+        this.visited.add(node.id);
+        this.order.push(node);
+    }
+    // ── Emission ──────────────────────────────────────────────────────
+    emit() {
+        for (const node of this.order) {
+            this.emitDefs(node);
+            const call = node.compileCall(this).trim();
+            if (call)
+                this.calls.push(call);
+            // Collect vertex attribute injections from this node
+            for (const inj of node.vertexInjections()) {
+                if (!this._vertexInjections.has(inj.varyingName)) {
+                    this._vertexInjections.set(inj.varyingName, { attrName: inj.attrName, attrType: inj.attrType });
+                }
+            }
+            // Collect extra uniforms (e.g. LightPath ray-type flags)
+            for (const [name, value] of Object.entries(node.extraUniforms())) {
+                if (!(name in this._uniforms)) {
+                    this._uniforms[name] = { value };
+                }
+            }
+        }
+    }
+    emitDefs(node) {
+        const NodeClass = node.constructor;
+        const isInstanceSpecific = NodeClass.instanceSpecificDef;
+        // Per-instance override takes priority
+        const fn = node.glslFunction
+            ?? NodeClass.glslFunction;
+        const defsSource = node.compileDefs();
+        if (isInstanceSpecific) {
+            // Each instance emits its own uniquely named function — no dedup
+            if (defsSource.trim())
+                this.defs.push(defsSource);
+        }
+        else {
+            // Shared function — emit once per node type
+            const key = node.nodeType;
+            if (!this.emittedDefs.has(key)) {
+                this.emittedDefs.add(key);
+                const source = fn ?? defsSource;
+                if (source.trim())
+                    this.defs.push(source);
+            }
+        }
+    }
+    // ── Validation ────────────────────────────────────────────────────
+    validate(root) {
+        if (ShaderConfig.errorLevel === 'off')
+            return;
+        this.validateNode(root, [root.nodeType]);
+    }
+    validateNode(node, path) {
+        for (const [, socket] of Object.entries(node.getInputSockets())) {
+            // Required input with no connection and no usable default
+            if (socket.required && !socket.isConnected()) {
+                ShaderNodeError.throw({
+                    nodeType: node.nodeType,
+                    nodeId: node.id,
+                    inputName: socket.name,
+                    problem: `Required input "${socket.name}" has no connection.`,
+                    fix: `Connect a node output to ${node.nodeType}.input("${socket.name}").`,
+                    graphPath: path,
+                });
+            }
+            if (socket.connection) {
+                const upstream = socket.connection;
+                // Type compatibility check
+                const compatible = this.typesCompatible(upstream.type, socket.type);
+                if (!compatible) {
+                    ShaderNodeError.throw({
+                        nodeType: node.nodeType,
+                        nodeId: node.id,
+                        inputName: socket.name,
+                        problem: `Type mismatch. Input "${socket.name}" expects "${socket.type}" but received "${upstream.type}" from ${upstream.node.nodeType}.output("${upstream.name}").`,
+                        fix: ShaderConfig.errorLevel === 'verbose'
+                            ? `Use an output socket of type "${socket.type}", or insert a conversion node between them.`
+                            : undefined,
+                        graphPath: path,
+                    });
+                }
+                // Recurse
+                this.validateNode(upstream.node, [upstream.node.nodeType, ...path]);
+            }
+        }
+    }
+    typesCompatible(from, to) {
+        if (from === to)
+            return true;
+        // shader and color are both vec3 — compatible
+        if ((from === 'shader' || from === 'color') && (to === 'shader' || to === 'color'))
+            return true;
+        return false;
+    }
+    // ── GLSL builders ─────────────────────────────────────────────────
+    buildVertexShader() {
+        const customAttrs = [...this._vertexInjections.entries()]
+            .map(([vName, { attrName, attrType }]) => `attribute ${attrType} ${attrName};\nvarying  ${attrType} ${vName};`)
+            .join('\n');
+        const customAssigns = [...this._vertexInjections.entries()]
+            .map(([vName, { attrName }]) => `  ${vName} = ${attrName};`)
+            .join('\n');
+        return `
+varying vec2 vUv;
+varying vec3 vNormal;
+varying vec3 vPosition;
+${customAttrs}
+
+void main() {
+  vUv       = uv;
+  vNormal   = normalize(mat3(transpose(inverse(modelMatrix))) * normal);
+  vPosition = (modelMatrix * vec4(position, 1.0)).xyz;
+${customAssigns}
+  gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+}`.trim();
+    }
+    buildUniformDeclarations() {
+        return Object.entries(this._uniforms)
+            .map(([name, { value }]) => Array.isArray(value) ? `uniform vec3 ${name};` : `uniform float ${name};`)
+            .join('\n');
+    }
+    buildFragmentShader() {
+        const uniformsBlock = this.buildUniformDeclarations();
+        const customVaryings = [...this._vertexInjections.entries()]
+            .map(([vName, { attrType }]) => `varying ${attrType} ${vName};`)
+            .join('\n');
+        const defsBlock = this.defs.join('\n\n');
+        const callsBlock = this.calls.map(c => `  ${c}`).join('\n');
+        return `
+precision mediump float;
+
+varying vec2 vUv;
+varying vec3 vNormal;
+varying vec3 vPosition;
+${customVaryings}
+
+${uniformsBlock}
+
+${defsBlock}
+
+void main() {
+${callsBlock}
+}`.trim();
+    }
+    // ── Literal conversion ────────────────────────────────────────────
+    toLiteral(value, type) {
+        switch (type) {
+            case 'float':
+                return (typeof value === 'number' ? value : 0).toFixed(4);
+            case 'color':
+                return typeof value === 'string'
+                    ? this.hexToVec3(value)
+                    : 'vec3(1.0, 1.0, 1.0)';
+            case 'vector':
+                return 'vec2(vUv)';
+            case 'shader':
+                return 'vec3(0.0)';
+            default:
+                return 'vec3(1.0)';
+        }
+    }
+    static hexToRgbArray(hex) {
+        const h = hex.replace('#', '');
+        return [
+            parseInt(h.substring(0, 2), 16) / 255,
+            parseInt(h.substring(2, 4), 16) / 255,
+            parseInt(h.substring(4, 6), 16) / 255,
+        ];
+    }
+    static hexToVec3(hex) {
+        const h = hex.replace('#', '');
+        const r = (parseInt(h.substring(0, 2), 16) / 255).toFixed(4);
+        const g = (parseInt(h.substring(2, 4), 16) / 255).toFixed(4);
+        const b = (parseInt(h.substring(4, 6), 16) / 255).toFixed(4);
+        return `vec3(${r}, ${g}, ${b})`;
+    }
+    hexToVec3(hex) {
+        return CompileContext.hexToVec3(hex);
+    }
+}

package/dist/core/InputNode.d.ts

@@ -0,0 +1,11 @@
+import { ShaderNode } from './ShaderNode.js';
+import type { InputSocket } from './InputSocket.js';
+/**
+ * Source node — outputs only, no upstream connections.
+ * Examples: TextureCoordinate, Value, RGB constant.
+ */
+export declare abstract class InputNode extends ShaderNode {
+    getInputSockets(): Record<string, InputSocket<unknown>>;
+    compileDefs(): string;
+}
+//# sourceMappingURL=InputNode.d.ts.map

package/dist/core/InputNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InputNode.d.ts","sourceRoot":"","sources":["../../src/core/InputNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAC5C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAEnD;;;GAGG;AACH,8BAAsB,SAAU,SAAQ,UAAU;IAChD,eAAe,IAAI,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,OAAO,CAAC,CAAC;IAIvD,WAAW,IAAI,MAAM;CAGtB"}

package/dist/core/InputNode.js

@@ -0,0 +1,13 @@
+import { ShaderNode } from './ShaderNode.js';
+/**
+ * Source node — outputs only, no upstream connections.
+ * Examples: TextureCoordinate, Value, RGB constant.
+ */
+export class InputNode extends ShaderNode {
+    getInputSockets() {
+        return {};
+    }
+    compileDefs() {
+        return '';
+    }
+}

package/dist/core/InputSocket.d.ts

@@ -0,0 +1,21 @@
+import type { SocketType } from './SocketType.js';
+import type { OutputSocket } from './OutputSocket.js';
+/**
+ * Represents an input connection point on a node.
+ * Accepts either a literal value or a connected OutputSocket.
+ */
+export declare class InputSocket<T> {
+    readonly name: string;
+    readonly type: SocketType;
+    readonly defaultValue: T;
+    readonly required: boolean;
+    /** Connected upstream socket — overrides value when set. */
+    connection: OutputSocket | null;
+    /** GLSL uniform name for this socket. Set by createInputs for float inputs. */
+    uniformName: string | null;
+    constructor(name: string, type: SocketType, defaultValue: T, required?: boolean);
+    /** The literal value — used when no connection is present. */
+    get value(): T;
+    isConnected(): boolean;
+}
+//# sourceMappingURL=InputSocket.d.ts.map

package/dist/core/InputSocket.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InputSocket.d.ts","sourceRoot":"","sources":["../../src/core/InputSocket.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AACjD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAErD;;;GAGG;AACH,qBAAa,WAAW,CAAC,CAAC;aAQN,IAAI,EAAU,MAAM;aACpB,IAAI,EAAU,UAAU;aACxB,YAAY,EAAE,CAAC;aACf,QAAQ,EAAM,OAAO;IAVvC,4DAA4D;IAC5D,UAAU,EAAE,YAAY,GAAG,IAAI,CAAO;IAEtC,+EAA+E;IAC/E,WAAW,EAAE,MAAM,GAAG,IAAI,CAAO;gBAGf,IAAI,EAAU,MAAM,EACpB,IAAI,EAAU,UAAU,EACxB,YAAY,EAAE,CAAC,EACf,QAAQ,GAAM,OAAe;IAG/C,8DAA8D;IAC9D,IAAI,KAAK,IAAI,CAAC,CAEb;IAED,WAAW,IAAI,OAAO;CAGvB"}

package/dist/core/InputSocket.js

@@ -0,0 +1,23 @@
+/**
+ * Represents an input connection point on a node.
+ * Accepts either a literal value or a connected OutputSocket.
+ */
+export class InputSocket {
+    constructor(name, type, defaultValue, required = false) {
+        this.name = name;
+        this.type = type;
+        this.defaultValue = defaultValue;
+        this.required = required;
+        /** Connected upstream socket — overrides value when set. */
+        this.connection = null;
+        /** GLSL uniform name for this socket. Set by createInputs for float inputs. */
+        this.uniformName = null;
+    }
+    /** The literal value — used when no connection is present. */
+    get value() {
+        return this.defaultValue;
+    }
+    isConnected() {
+        return this.connection !== null;
+    }
+}

package/dist/core/OutputNode.d.ts

@@ -0,0 +1,30 @@
+import { ShaderNode } from './ShaderNode.js';
+import { ShaderMaterial } from 'three';
+import type { OutputSocket } from './OutputSocket.js';
+/**
+ * Terminal node — inputs only, no outputs.
+ * Owns compile() — the entry point for the entire graph.
+ * Example: MaterialOutput.
+ */
+export declare abstract class OutputNode extends ShaderNode {
+    /** The compiled THREE.ShaderMaterial — available after compile() is called. */
+    material: ShaderMaterial | null;
+    getOutputSockets(): Record<string, OutputSocket>;
+    compileDefs(): string;
+    /**
+     * Walks the full node graph, validates all connections,
+     * compiles to GLSL, and returns a ready-to-use THREE.ShaderMaterial.
+     *
+     * The result is also stored on .material so it can be reused
+     * across any number of meshes without recompiling.
+     *
+     * @example
+     * const blueMetal = new MaterialOutput({ surface: bsdf.output('BSDF') })
+     * blueMetal.compile()
+     *
+     * const torus  = new THREE.Mesh(torusGeo,  blueMetal.material)
+     * const sphere = new THREE.Mesh(sphereGeo, blueMetal.material)
+     */
+    compile(): ShaderMaterial;
+}
+//# sourceMappingURL=OutputNode.d.ts.map

package/dist/core/OutputNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OutputNode.d.ts","sourceRoot":"","sources":["../../src/core/OutputNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAE5C,OAAO,EAAE,cAAc,EAAW,MAAM,OAAO,CAAA;AAC/C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAErD;;;;GAIG;AACH,8BAAsB,UAAW,SAAQ,UAAU;IACjD,+EAA+E;IAC/E,QAAQ,EAAE,cAAc,GAAG,IAAI,CAAO;IAEtC,gBAAgB,IAAI,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC;IAIhD,WAAW,IAAI,MAAM;IAIrB;;;;;;;;;;;;;OAaG;IACH,OAAO,IAAI,cAAc;CAyB1B"}

package/dist/core/OutputNode.js

@@ -0,0 +1,60 @@
+import { ShaderNode } from './ShaderNode.js';
+import { CompileContext } from './CompileContext.js';
+import { ShaderMaterial, Vector3 } from 'three';
+/**
+ * Terminal node — inputs only, no outputs.
+ * Owns compile() — the entry point for the entire graph.
+ * Example: MaterialOutput.
+ */
+export class OutputNode extends ShaderNode {
+    constructor() {
+        super(...arguments);
+        /** The compiled THREE.ShaderMaterial — available after compile() is called. */
+        this.material = null;
+    }
+    getOutputSockets() {
+        return {};
+    }
+    compileDefs() {
+        return '';
+    }
+    /**
+     * Walks the full node graph, validates all connections,
+     * compiles to GLSL, and returns a ready-to-use THREE.ShaderMaterial.
+     *
+     * The result is also stored on .material so it can be reused
+     * across any number of meshes without recompiling.
+     *
+     * @example
+     * const blueMetal = new MaterialOutput({ surface: bsdf.output('BSDF') })
+     * blueMetal.compile()
+     *
+     * const torus  = new THREE.Mesh(torusGeo,  blueMetal.material)
+     * const sphere = new THREE.Mesh(sphereGeo, blueMetal.material)
+     */
+    compile() {
+        const ctx = new CompileContext();
+        const compiled = ctx.compile(this);
+        this.material = new ShaderMaterial({
+            vertexShader: compiled.vertexShader,
+            fragmentShader: compiled.fragmentShader,
+            uniforms: compiled.uniforms,
+        });
+        // Inject default scene-lighting uniforms used by PrincipledBSDF.
+        // Users can override these after compile() to match their scene lights.
+        if (!this.material.uniforms.uSunDirection) {
+            this.material.uniforms.uSunDirection = { value: new Vector3(1, 2, 1).normalize() };
+        }
+        if (!this.material.uniforms.uSunColor) {
+            this.material.uniforms.uSunColor = { value: new Vector3(1.0, 0.97, 0.9) };
+        }
+        if (!this.material.uniforms.uAmbientColor) {
+            this.material.uniforms.uAmbientColor = { value: new Vector3(0.05, 0.08, 0.18) };
+        }
+        // Wire each node's parameters object to the live GPU uniforms
+        for (const node of compiled.nodes) {
+            node._wireParameters(this.material.uniforms);
+        }
+        return this.material;
+    }
+}

package/dist/core/OutputSocket.d.ts

@@ -0,0 +1,18 @@
+import type { SocketType } from './SocketType.js';
+import type { ShaderNode } from './ShaderNode.js';
+/**
+ * Represents an output connection point on a node.
+ * Pass to a downstream node's input to wire the graph.
+ *
+ * Example:
+ *   const noise = new NoiseTexture({ scale: 3.0 })
+ *   noise.output('Fac')    // returns an OutputSocket
+ *   noise.output('Color')  // returns an OutputSocket
+ */
+export declare class OutputSocket {
+    readonly node: ShaderNode;
+    readonly name: string;
+    readonly type: SocketType;
+    constructor(node: ShaderNode, name: string, type: SocketType);
+}
+//# sourceMappingURL=OutputSocket.d.ts.map

package/dist/core/OutputSocket.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OutputSocket.d.ts","sourceRoot":"","sources":["../../src/core/OutputSocket.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AACjD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAEjD;;;;;;;;GAQG;AACH,qBAAa,YAAY;aAEL,IAAI,EAAE,UAAU;aAChB,IAAI,EAAE,MAAM;aACZ,IAAI,EAAE,UAAU;gBAFhB,IAAI,EAAE,UAAU,EAChB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,UAAU;CAEnC"}

package/dist/core/OutputSocket.js

@@ -0,0 +1,16 @@
+/**
+ * Represents an output connection point on a node.
+ * Pass to a downstream node's input to wire the graph.
+ *
+ * Example:
+ *   const noise = new NoiseTexture({ scale: 3.0 })
+ *   noise.output('Fac')    // returns an OutputSocket
+ *   noise.output('Color')  // returns an OutputSocket
+ */
+export class OutputSocket {
+    constructor(node, name, type) {
+        this.node = node;
+        this.name = name;
+        this.type = type;
+    }
+}

package/dist/core/ProcessNode.d.ts

@@ -0,0 +1,8 @@
+import { ShaderNode } from './ShaderNode.js';
+/**
+ * Transform node — has both inputs and outputs.
+ * Examples: NoiseTexture, ColorRamp, PrincipledBSDF.
+ */
+export declare abstract class ProcessNode extends ShaderNode {
+}
+//# sourceMappingURL=ProcessNode.d.ts.map

package/dist/core/ProcessNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProcessNode.d.ts","sourceRoot":"","sources":["../../src/core/ProcessNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAE5C;;;GAGG;AACH,8BAAsB,WAAY,SAAQ,UAAU;CAAG"}

package/dist/core/ProcessNode.js

@@ -0,0 +1,7 @@
+import { ShaderNode } from './ShaderNode.js';
+/**
+ * Transform node — has both inputs and outputs.
+ * Examples: NoiseTexture, ColorRamp, PrincipledBSDF.
+ */
+export class ProcessNode extends ShaderNode {
+}

package/dist/core/ShaderConfig.d.ts

@@ -0,0 +1,13 @@
+export type ErrorLevel = 'verbose' | 'standard' | 'off';
+/**
+ * Global configuration for @st-shader-core.
+ *
+ * Set errorLevel before building any materials:
+ *   ShaderConfig.errorLevel = 'verbose'   // development
+ *   ShaderConfig.errorLevel = 'standard'  // production (default)
+ *   ShaderConfig.errorLevel = 'off'       // maximum performance
+ */
+export declare const ShaderConfig: {
+    errorLevel: ErrorLevel;
+};
+//# sourceMappingURL=ShaderConfig.d.ts.map

package/dist/core/ShaderConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ShaderConfig.d.ts","sourceRoot":"","sources":["../../src/core/ShaderConfig.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,UAAU,GAAG,SAAS,GAAG,UAAU,GAAG,KAAK,CAAA;AAEvD;;;;;;;GAOG;AACH,eAAO,MAAM,YAAY;gBACG,UAAU;CACrC,CAAA"}

package/dist/core/ShaderConfig.js

@@ -0,0 +1,11 @@
+/**
+ * Global configuration for @st-shader-core.
+ *
+ * Set errorLevel before building any materials:
+ *   ShaderConfig.errorLevel = 'verbose'   // development
+ *   ShaderConfig.errorLevel = 'standard'  // production (default)
+ *   ShaderConfig.errorLevel = 'off'       // maximum performance
+ */
+export const ShaderConfig = {
+    errorLevel: 'standard',
+};