reze-engine 0.17.1 → 0.18.0

package/dist/graph/presets/hair.js

@@ -0,0 +1,79 @@
+// M_Hair — 仿深空之眼渲染预设v1.0_by_小绿毛猫, as a StyleGraph. Node ids mirror the
+// Blender node names referenced in shaders/materials/hair.ts comments; compiled with
+// { inlineParams: true } this graph must reproduce HAIR_SHADER_WGSL's fragment body
+// (golden test #1 — see tests/graph.test.mjs).
+//
+// Inherited authoring decisions from the hand port: the noise→bump subtree on
+// Principled.Normal is omitted (imperceptible at 0.2 mix weight), and Blender's bevel
+// node is approximated by saturate(normal.y) — Blender Z-up ⇒ engine Y-up.
+//
+// The object is pure JSON (no functions/undefined) — JSON.stringify round-trips it,
+// which is how reze.design will ship additional presets.
+export const HAIR_GRAPH = {
+    version: 1,
+    name: "Hair",
+    slot: "hair",
+    nodes: [
+        { id: "tex", type: "texture" },
+        { id: "geo", type: "geometry" },
+        { id: "hs_shadow", type: "hue_sat", inputs: { hue: 0.5, saturation: 1.2, value: 0.5, fac: 1.0 } },
+        { id: "hs_002", type: "hue_sat", inputs: { hue: 0.48, saturation: 1.2, value: 0.7, fac: 1.0 } },
+        { id: "hs_001", type: "hue_sat", inputs: { hue: 0.5, saturation: 1.5, value: 1.0, fac: 1.0 } },
+        { id: "str", type: "shader_to_rgb_diffuse" },
+        { id: "ramp_008", type: "ramp_constant", inputs: { pos0: 0.0, color0: [0, 0, 0, 1], pos1: 0.2966, color1: [1, 1, 1, 1] } },
+        { id: "mix_004", type: "mix/blend" },
+        { id: "bc", type: "bright_contrast", inputs: { bright: 0.1, contrast: 0.2 } },
+        { id: "sep_n", type: "separate_xyz" },
+        { id: "bevel_clamp", type: "math/clamp01" },
+        { id: "mix_003", type: "mix/blend" },
+        { id: "fres", type: "fresnel", inputs: { ior: 1.45 } },
+        { id: "lw", type: "layer_weight/fresnel", inputs: { blend: 0.61 } },
+        { id: "rim_mul", type: "math/multiply" },
+        { id: "rim_pow", type: "math/power", inputs: { b: 0.6300000548362732 } },
+        {
+            id: "mix_shader_002",
+            type: "mix_shader",
+            inputs: { b: [0.1673291176557541, 0.1673291176557541, 0.1673291176557541] },
+        },
+        { id: "gate", type: "math/greater_than", inputs: { b: 0.15000000596046448 } },
+        { id: "gate_scale", type: "math/multiply", inputs: { b: 0.1 } },
+        { id: "npr_add", type: "mix/add_emit" },
+        {
+            id: "principled",
+            type: "principled",
+            inputs: { metallic: 0.0, specular: 1.0, roughness: 0.3, spec_clamp: 10.0, sheen: 0.0, sheen_tint: 0.0 },
+        },
+        { id: "mix_shader_001", type: "mix_shader", inputs: { fac: 0.2 } },
+    ],
+    links: [
+        { from: { node: "tex", socket: "color" }, to: { node: "hs_shadow", socket: "color" } },
+        { from: { node: "hs_shadow", socket: "color" }, to: { node: "hs_002", socket: "color" } },
+        { from: { node: "tex", socket: "color" }, to: { node: "hs_001", socket: "color" } },
+        { from: { node: "str", socket: "value" }, to: { node: "ramp_008", socket: "fac" } },
+        { from: { node: "ramp_008", socket: "fac_out" }, to: { node: "mix_004", socket: "fac" } },
+        { from: { node: "hs_002", socket: "color" }, to: { node: "mix_004", socket: "a" } },
+        { from: { node: "hs_001", socket: "color" }, to: { node: "mix_004", socket: "b" } },
+        { from: { node: "mix_004", socket: "color" }, to: { node: "bc", socket: "color" } },
+        { from: { node: "geo", socket: "normal" }, to: { node: "sep_n", socket: "vector" } },
+        { from: { node: "sep_n", socket: "y" }, to: { node: "bevel_clamp", socket: "a" } },
+        { from: { node: "bevel_clamp", socket: "value" }, to: { node: "mix_003", socket: "fac" } },
+        { from: { node: "bc", socket: "color" }, to: { node: "mix_003", socket: "a" } },
+        { from: { node: "hs_002", socket: "color" }, to: { node: "mix_003", socket: "b" } },
+        { from: { node: "fres", socket: "value" }, to: { node: "rim_mul", socket: "a" } },
+        { from: { node: "lw", socket: "value" }, to: { node: "rim_mul", socket: "b" } },
+        { from: { node: "rim_mul", socket: "value" }, to: { node: "rim_pow", socket: "a" } },
+        { from: { node: "mix_003", socket: "color" }, to: { node: "mix_shader_002", socket: "a" } },
+        { from: { node: "rim_pow", socket: "value" }, to: { node: "mix_shader_002", socket: "fac" } },
+        { from: { node: "tex", socket: "color" }, to: { node: "gate", socket: "a" } },
+        { from: { node: "gate", socket: "value" }, to: { node: "gate_scale", socket: "a" } },
+        { from: { node: "mix_shader_002", socket: "color" }, to: { node: "npr_add", socket: "a" } },
+        { from: { node: "gate_scale", socket: "value" }, to: { node: "npr_add", socket: "b" } },
+        { from: { node: "bc", socket: "color" }, to: { node: "principled", socket: "base" } },
+        { from: { node: "npr_add", socket: "color" }, to: { node: "mix_shader_001", socket: "a" } },
+        { from: { node: "principled", socket: "color" }, to: { node: "mix_shader_001", socket: "b" } },
+    ],
+    output: { node: "mix_shader_001", socket: "color" },
+    // Adjust-tier params deliberately absent: which sockets deserve sliders (and what
+    // they're called) is preset-author curation done in reze.design, not engine data.
+    // The exposed-param mechanism itself is covered by tests/graph.test.mjs.
+};

package/dist/graph/presets/metal.d.ts

@@ -0,0 +1,3 @@
+import type { StyleGraph } from "../schema";
+export declare const METAL_GRAPH: StyleGraph;
+//# sourceMappingURL=metal.d.ts.map

package/dist/graph/presets/metal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metal.d.ts","sourceRoot":"","sources":["../../../src/graph/presets/metal.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAA;AAE3C,eAAO,MAAM,WAAW,EAAE,UAoDzB,CAAA"}

package/dist/graph/presets/metal.js

@@ -0,0 +1,58 @@
+// M_Metal as a StyleGraph — port of shaders/materials/metal.ts.
+// Metallic Principled (Metallic=1, Specular=1, Roughness=0.3) with a
+// reflection-coord voronoi driving base color (metallic sparkle), plus an NPR
+// toon/overlay emission stack mixed at Fac=0.6967. The voronoi Color→ramp Fac
+// link goes through Blender's implicit BT.601 conversion (color_to_value).
+export const METAL_GRAPH = {
+    version: 1,
+    name: "Metal",
+    slot: "metal",
+    nodes: [
+        { id: "tex", type: "texture" },
+        { id: "geo", type: "geometry" },
+        { id: "tex_tint", type: "hue_sat", inputs: { hue: 0.5, saturation: 1.0, value: 0.800000011920929, fac: 1.0 } },
+        { id: "str", type: "shader_to_rgb_diffuse" },
+        { id: "ramp_008", type: "ramp_constant_aa", inputs: { edge: 0.2966 } },
+        { id: "mix04_fac", type: "math/multiply", inputs: { b: 0.5 } },
+        { id: "dark_tex", type: "hue_sat", inputs: { hue: 0.5, saturation: 1.0, value: 0.19999998807907104, fac: 1.0 } },
+        { id: "mix_004", type: "mix/blend" },
+        { id: "hue_004", type: "hue_sat", inputs: { hue: 0.5, saturation: 1.0, value: 2.0, fac: 1.0 } },
+        { id: "npr_overlay", type: "mix/overlay", inputs: { fac: 1.0 } },
+        { id: "npr_emit", type: "emission", inputs: { strength: 8.100000381469727 } },
+        { id: "voro_cross", type: "vect_cross", inputs: { b: [0, 1, 0] } },
+        { id: "voro", type: "tex_voronoi/color", inputs: { scale: 4.3 } },
+        { id: "voro_ramp", type: "ramp_linear", inputs: { pos0: 0.0, pos1: 1.0 } },
+        { id: "hue_006", type: "hue_sat", inputs: { hue: 0.5, saturation: 1.5, value: 1.2999999523162842, fac: 1.0 } },
+        { id: "albedo", type: "mix/blend" },
+        {
+            id: "principled",
+            type: "principled",
+            inputs: { metallic: 1.0, specular: 1.0, roughness: 0.3, spec_clamp: 1e30, sheen: 0.0, sheen_tint: 0.0 },
+        },
+        { id: "mix_shader_001", type: "mix_shader", inputs: { fac: 0.6967 } },
+    ],
+    links: [
+        { from: { node: "tex", socket: "color" }, to: { node: "tex_tint", socket: "color" } },
+        { from: { node: "str", socket: "value" }, to: { node: "ramp_008", socket: "fac" } },
+        { from: { node: "ramp_008", socket: "fac_out" }, to: { node: "mix04_fac", socket: "a" } },
+        { from: { node: "tex_tint", socket: "color" }, to: { node: "dark_tex", socket: "color" } },
+        { from: { node: "mix04_fac", socket: "value" }, to: { node: "mix_004", socket: "fac" } },
+        { from: { node: "dark_tex", socket: "color" }, to: { node: "mix_004", socket: "a" } },
+        { from: { node: "tex_tint", socket: "color" }, to: { node: "mix_004", socket: "b" } },
+        { from: { node: "mix_004", socket: "color" }, to: { node: "hue_004", socket: "color" } },
+        { from: { node: "mix_004", socket: "color" }, to: { node: "npr_overlay", socket: "a" } },
+        { from: { node: "hue_004", socket: "color" }, to: { node: "npr_overlay", socket: "b" } },
+        { from: { node: "npr_overlay", socket: "color" }, to: { node: "npr_emit", socket: "color" } },
+        { from: { node: "geo", socket: "reflection" }, to: { node: "voro_cross", socket: "a" } },
+        { from: { node: "voro_cross", socket: "vector" }, to: { node: "voro", socket: "vector" } },
+        { from: { node: "voro", socket: "color" }, to: { node: "voro_ramp", socket: "fac" } },
+        { from: { node: "tex_tint", socket: "color" }, to: { node: "hue_006", socket: "color" } },
+        { from: { node: "voro_ramp", socket: "fac_out" }, to: { node: "albedo", socket: "fac" } },
+        { from: { node: "voro_ramp", socket: "fac_out" }, to: { node: "albedo", socket: "a" } },
+        { from: { node: "hue_006", socket: "color" }, to: { node: "albedo", socket: "b" } },
+        { from: { node: "albedo", socket: "color" }, to: { node: "principled", socket: "base" } },
+        { from: { node: "npr_emit", socket: "color" }, to: { node: "mix_shader_001", socket: "a" } },
+        { from: { node: "principled", socket: "color" }, to: { node: "mix_shader_001", socket: "b" } },
+    ],
+    output: { node: "mix_shader_001", socket: "color" },
+};

package/dist/graph/presets/stockings.d.ts

@@ -0,0 +1,3 @@
+import type { StyleGraph } from "../schema";
+export declare const STOCKINGS_GRAPH: StyleGraph;
+//# sourceMappingURL=stockings.d.ts.map

package/dist/graph/presets/stockings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stockings.d.ts","sourceRoot":"","sources":["../../../src/graph/presets/stockings.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAA;AAE3C,eAAO,MAAM,eAAe,EAAE,UA8C7B,CAAA"}

package/dist/graph/presets/stockings.js

@@ -0,0 +1,54 @@
+// M_Stockings as a StyleGraph — port of shaders/materials/stockings.ts.
+// A bbox-gradient × facing-rim mask drives a Mix Shader between an HSV-boosted
+// emission (val 5×) and a sheen Principled. The hashed-alpha discard and the
+// alpha=1 output are slot-owned (see STOCKINGS_TEMPLATE in slots.ts) — the graph
+// computes only the radiance. Blender's Generated coord is approximated with UV,
+// as in the hand port. The grayscale mask feeds Mix Shader Fac through Blender's
+// implicit BT.601 color→float conversion (equal-component vector → same scalar).
+export const STOCKINGS_GRAPH = {
+    version: 1,
+    name: "Stockings",
+    slot: "stockings",
+    nodes: [
+        { id: "tex", type: "texture" },
+        { id: "geo", type: "geometry" },
+        { id: "map", type: "mapping", inputs: { loc: [1.0, 1.0, 1.0], rot: [0.0, 1.5708, 1.5708] } },
+        { id: "grad", type: "tex_gradient" },
+        { id: "ramp_001", type: "ramp_tri" },
+        { id: "ramp_002", type: "ramp_cardinal", inputs: { pos0: 0.0, pos1: 0.9565 } },
+        { id: "facing", type: "layer_weight/facing", inputs: { blend: 0.4 } },
+        { id: "ramp_face", type: "ramp_cardinal", inputs: { pos0: 0.0, pos1: 0.5435 } },
+        { id: "mix_001", type: "mix/blend", inputs: { fac: 0.5, a: [1.0, 1.0, 1.0] } },
+        { id: "mask", type: "mix/lighten", inputs: { fac: 0.5 } },
+        { id: "emission_hs", type: "hue_sat", inputs: { hue: 0.5, saturation: 1.0, value: 5.0, fac: 1.0 } },
+        {
+            id: "principled",
+            type: "principled",
+            inputs: {
+                metallic: 0.1,
+                specular: 1.0,
+                roughness: 0.5,
+                spec_clamp: 1e30,
+                sheen: 0.7017999887466431,
+                sheen_tint: 0.5,
+            },
+        },
+        { id: "mix_shader_001", type: "mix_shader" },
+    ],
+    links: [
+        { from: { node: "geo", socket: "uv" }, to: { node: "map", socket: "vector" } },
+        { from: { node: "map", socket: "vector" }, to: { node: "grad", socket: "vector" } },
+        { from: { node: "grad", socket: "value" }, to: { node: "ramp_001", socket: "fac" } },
+        { from: { node: "ramp_001", socket: "value" }, to: { node: "ramp_002", socket: "fac" } },
+        { from: { node: "facing", socket: "value" }, to: { node: "ramp_face", socket: "fac" } },
+        { from: { node: "ramp_face", socket: "fac_out" }, to: { node: "mix_001", socket: "b" } },
+        { from: { node: "mix_001", socket: "color" }, to: { node: "mask", socket: "a" } },
+        { from: { node: "ramp_002", socket: "fac_out" }, to: { node: "mask", socket: "b" } },
+        { from: { node: "tex", socket: "color" }, to: { node: "emission_hs", socket: "color" } },
+        { from: { node: "tex", socket: "color" }, to: { node: "principled", socket: "base" } },
+        { from: { node: "emission_hs", socket: "color" }, to: { node: "mix_shader_001", socket: "a" } },
+        { from: { node: "principled", socket: "color" }, to: { node: "mix_shader_001", socket: "b" } },
+        { from: { node: "mask", socket: "color" }, to: { node: "mix_shader_001", socket: "fac" } },
+    ],
+    output: { node: "mix_shader_001", socket: "color" },
+};

package/dist/graph/registry.d.ts

@@ -0,0 +1,28 @@
+import type { SocketValue } from "./schema";
+export type SockT = "float" | "color" | "vector" | "vec4";
+export type InputSpec = {
+    type: SockT;
+    default?: SocketValue;
+    /** Socket is meaningless as a literal (e.g. the color being processed) — must be linked. */
+    requiresLink?: boolean;
+    /** Unlinked fallback is a template local, not a literal (e.g. principled.normal → n). */
+    contextDefault?: string;
+};
+export type NodeSpec = {
+    inputs: Record<string, InputSpec>;
+    outputs: Record<string, SockT>;
+    /** RHS expression for this node's `let`, from resolved arg expressions keyed by socket. */
+    emit?: (args: Record<string, string>) => string;
+    /** Context nodes tap template locals directly — no `let` emitted. */
+    contextOutputs?: Record<string, string>;
+    /** Swizzle applied to the node's variable per output socket (default: none). */
+    outputSelect?: Record<string, string>;
+};
+export declare function fmtFloat(x: number): string;
+export declare function fmtValue(value: SocketValue, type: SockT): string;
+/** Does a literal's shape fit a socket type? (Scalar splats onto color/vector/vec4.) */
+export declare function literalFits(value: SocketValue, type: SockT): boolean;
+export declare function canConvert(from: SockT, to: SockT): boolean;
+export declare function convert(from: SockT, to: SockT, expr: string): string;
+export declare const NODE_REGISTRY: Record<string, NodeSpec>;
+//# sourceMappingURL=registry.d.ts.map

package/dist/graph/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/graph/registry.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAE3C,MAAM,MAAM,KAAK,GAAG,OAAO,GAAG,OAAO,GAAG,QAAQ,GAAG,MAAM,CAAA;AAEzD,MAAM,MAAM,SAAS,GAAG;IACtB,IAAI,EAAE,KAAK,CAAA;IACX,OAAO,CAAC,EAAE,WAAW,CAAA;IACrB,4FAA4F;IAC5F,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,yFAAyF;IACzF,cAAc,CAAC,EAAE,MAAM,CAAA;CACxB,CAAA;AAED,MAAM,MAAM,QAAQ,GAAG;IACrB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAA;IACjC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAA;IAC9B,2FAA2F;IAC3F,IAAI,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,MAAM,CAAA;IAC/C,qEAAqE;IACrE,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACvC,gFAAgF;IAChF,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACtC,CAAA;AAMD,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAI1C;AAED,wBAAgB,QAAQ,CAAC,KAAK,EAAE,WAAW,EAAE,IAAI,EAAE,KAAK,GAAG,MAAM,CAgBhE;AAED,wFAAwF;AACxF,wBAAgB,WAAW,CAAC,KAAK,EAAE,WAAW,EAAE,IAAI,EAAE,KAAK,GAAG,OAAO,CAIpE;AAMD,wBAAgB,UAAU,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,GAAG,OAAO,CAM1D;AAED,wBAAgB,OAAO,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAKpE;AA6BD,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CA+OlD,CAAA"}

package/dist/graph/registry.js

@@ -0,0 +1,322 @@
+// Node registry: one entry per Blender-equivalent node backed by NODES_WGSL (nodes.ts).
+// The registry adds no WGSL of its own — a node type exists here only if its function
+// already exists (validated against EEVEE) in the shader library, or is a WGSL builtin.
+// Semantics are frozen Blender 3.6 legacy-EEVEE; enum modes (math op, mix blend type,
+// ramp interpolation) are part of the type string so they are unambiguously topology.
+// ─── Literal formatting ───────────────────────────────────────────────
+// Deterministic: same graph JSON → byte-identical WGSL. String(x) is JS shortest
+// round-trip, so full-precision Blender constants (0.15000000596046448) survive.
+export function fmtFloat(x) {
+    if (!Number.isFinite(x))
+        throw new Error(`non-finite literal: ${x}`);
+    const s = String(x);
+    return /[.e]/.test(s) ? s : s + ".0";
+}
+export function fmtValue(value, type) {
+    if (typeof value === "number") {
+        if (type === "float")
+            return fmtFloat(value);
+        if (type === "color" || type === "vector")
+            return `vec3f(${fmtFloat(value)})`;
+        return `vec4f(vec3f(${fmtFloat(value)}), 1.0)`;
+    }
+    if (value.length === 3) {
+        const [x, y, z] = value;
+        if (type === "vec4")
+            return `vec4f(${fmtFloat(x)}, ${fmtFloat(y)}, ${fmtFloat(z)}, 1.0)`;
+        if (type === "float")
+            throw new Error(`vector literal on float socket`);
+        // All-equal shorthand matches the hand-written shaders (vec3f(0.167…)).
+        if (x === y && y === z)
+            return `vec3f(${fmtFloat(x)})`;
+        return `vec3f(${fmtFloat(x)}, ${fmtFloat(y)}, ${fmtFloat(z)})`;
+    }
+    if (type !== "vec4")
+        throw new Error(`vec4 literal on ${type} socket`);
+    return `vec4f(${value.map(fmtFloat).join(", ")})`;
+}
+/** Does a literal's shape fit a socket type? (Scalar splats onto color/vector/vec4.) */
+export function literalFits(value, type) {
+    if (typeof value === "number")
+        return true;
+    if (value.length === 3)
+        return type !== "float";
+    return type === "vec4";
+}
+// ─── Implicit socket conversions (Blender-faithful) ──────────────────
+// vec4 appears only on ramp stop-color literals — never linkable, so conversions
+// cover float/color/vector. vector→float is NOT implicit in Blender; rejected.
+export function canConvert(from, to) {
+    if (from === to)
+        return true;
+    if (from === "color" && to === "float")
+        return true; // BT.601 via color_to_value
+    if (from === "float" && (to === "color" || to === "vector"))
+        return true;
+    if ((from === "color" && to === "vector") || (from === "vector" && to === "color"))
+        return true;
+    return false;
+}
+export function convert(from, to, expr) {
+    if (from === to)
+        return expr;
+    if (from === "color" && to === "float")
+        return `color_to_value(${expr})`;
+    if (from === "float")
+        return `vec3f(${expr})`;
+    return expr; // color ↔ vector: bit-identical vec3f pass-through
+}
+// ─── Registry ─────────────────────────────────────────────────────────
+const F = (d, requiresLink = false) => ({ type: "float", default: d, requiresLink });
+const C = (d = [1, 1, 1], requiresLink = false) => ({
+    type: "color",
+    default: d,
+    requiresLink,
+});
+const V = (d = [0, 0, 0], requiresLink = false) => ({
+    type: "vector",
+    default: d,
+    requiresLink,
+});
+const V4 = (d) => ({ type: "vec4", default: d });
+const RAMP_INPUTS = {
+    fac: F(0.5, true),
+    pos0: F(0),
+    color0: V4([0, 0, 0, 1]),
+    pos1: F(1),
+    color1: V4([1, 1, 1, 1]),
+};
+const RAMP_OUTPUTS = { color: "color", alpha: "float", fac_out: "float" };
+// fac_out (.r) matches how a grayscale ramp feeds a scalar consumer in the hand ports —
+// routing through the BT.601 color→float conversion instead would change the value.
+const RAMP_SELECT = { color: ".rgb", alpha: ".a", fac_out: ".r" };
+export const NODE_REGISTRY = {
+    // ── Context inputs (template locals; no emission) ──
+    texture: {
+        inputs: {},
+        outputs: { color: "color", alpha: "float" },
+        contextOutputs: { color: "tex_color", alpha: "tex_s.a" },
+    },
+    geometry: {
+        inputs: {},
+        outputs: {
+            normal: "vector",
+            view: "vector",
+            world_pos: "vector",
+            rest_pos: "vector",
+            uv: "vector",
+            // Blender Texture Coordinate → Reflection (view ray mirrored on the normal);
+            // drives env-tracking patterns like metal's voronoi sparkle.
+            reflection: "vector",
+        },
+        contextOutputs: {
+            normal: "n",
+            view: "v",
+            world_pos: "input.worldPos",
+            rest_pos: "input.restPos",
+            uv: "vec3f(input.uv, 0.0)",
+            reflection: "reflect(-v, n)",
+        },
+    },
+    // ── Literals as nodes (for editor ergonomics; inlined literals work too) ──
+    value: { inputs: { value: F(0) }, outputs: { value: "float" }, emit: (a) => a.value },
+    rgb: { inputs: { color: C() }, outputs: { color: "color" }, emit: (a) => a.color },
+    // ── Color ──
+    hue_sat: {
+        inputs: { hue: F(0.5), saturation: F(1), value: F(1), fac: F(1), color: C([1, 1, 1], true) },
+        outputs: { color: "color" },
+        emit: (a) => `hue_sat(${a.hue}, ${a.saturation}, ${a.value}, ${a.fac}, ${a.color})`,
+    },
+    bright_contrast: {
+        inputs: { color: C([1, 1, 1], true), bright: F(0), contrast: F(0) },
+        outputs: { color: "color" },
+        emit: (a) => `bright_contrast(${a.color}, ${a.bright}, ${a.contrast})`,
+    },
+    invert: {
+        inputs: { fac: F(1), color: C([1, 1, 1], true) },
+        outputs: { color: "color" },
+        emit: (a) => `invert(${a.fac}, ${a.color})`,
+    },
+    ramp_constant: {
+        inputs: RAMP_INPUTS,
+        outputs: RAMP_OUTPUTS,
+        outputSelect: RAMP_SELECT,
+        emit: (a) => `ramp_constant(${a.fac}, ${a.pos0}, ${a.color0}, ${a.pos1}, ${a.color1})`,
+    },
+    ramp_linear: {
+        inputs: RAMP_INPUTS,
+        outputs: RAMP_OUTPUTS,
+        outputSelect: RAMP_SELECT,
+        emit: (a) => `ramp_linear(${a.fac}, ${a.pos0}, ${a.color0}, ${a.pos1}, ${a.color1})`,
+    },
+    ramp_cardinal: {
+        inputs: RAMP_INPUTS,
+        outputs: RAMP_OUTPUTS,
+        outputSelect: RAMP_SELECT,
+        emit: (a) => `ramp_cardinal(${a.fac}, ${a.pos0}, ${a.color0}, ${a.pos1}, ${a.color1})`,
+    },
+    ramp_constant_aa: {
+        inputs: { fac: F(0.5, true), edge: F(0.5), color0: V4([0, 0, 0, 1]), color1: V4([1, 1, 1, 1]) },
+        outputs: RAMP_OUTPUTS,
+        outputSelect: RAMP_SELECT,
+        emit: (a) => `ramp_constant_edge_aa(${a.fac}, ${a.edge}, ${a.color0}, ${a.color1})`,
+    },
+    // Blender ColorRamp LINEAR with 3 stops black→white→black (triangular peak at 0.5).
+    // The only >2-stop ramp the presets use; folded to closed form like the hand port.
+    ramp_tri: {
+        inputs: { fac: F(0.5, true) },
+        outputs: { value: "float" },
+        emit: (a) => `1.0 - abs(2.0 * ${a.fac} - 1.0)`,
+    },
+    // ── Math (enum op in type string) ──
+    "math/add": { inputs: { a: F(0), b: F(0) }, outputs: { value: "float" }, emit: (a) => `math_add(${a.a}, ${a.b})` },
+    "math/multiply": {
+        inputs: { a: F(0), b: F(0) },
+        outputs: { value: "float" },
+        emit: (a) => `math_multiply(${a.a}, ${a.b})`,
+    },
+    "math/power": {
+        inputs: { a: F(0), b: F(1) },
+        outputs: { value: "float" },
+        emit: (a) => `math_power(${a.a}, ${a.b})`,
+    },
+    "math/greater_than": {
+        inputs: { a: F(0), b: F(0.5) },
+        outputs: { value: "float" },
+        emit: (a) => `math_greater_than(${a.a}, ${a.b})`,
+    },
+    "math/clamp01": { inputs: { a: F(0) }, outputs: { value: "float" }, emit: (a) => `saturate(${a.a})` },
+    // ── Mix (blend type in type string) ──
+    "mix/blend": {
+        inputs: { fac: F(0.5), a: C([1, 1, 1], true), b: C() },
+        outputs: { color: "color" },
+        emit: (a) => `mix_blend(${a.fac}, ${a.a}, ${a.b})`,
+    },
+    "mix/overlay": {
+        inputs: { fac: F(0.5), a: C([1, 1, 1], true), b: C() },
+        outputs: { color: "color" },
+        emit: (a) => `mix_overlay(${a.fac}, ${a.a}, ${a.b})`,
+    },
+    "mix/multiply": {
+        inputs: { fac: F(0.5), a: C([1, 1, 1], true), b: C() },
+        outputs: { color: "color" },
+        emit: (a) => `mix_multiply(${a.fac}, ${a.a}, ${a.b})`,
+    },
+    "mix/lighten": {
+        inputs: { fac: F(0.5), a: C([1, 1, 1], true), b: C() },
+        outputs: { color: "color" },
+        emit: (a) => `mix_lighten(${a.fac}, ${a.a}, ${a.b})`,
+    },
+    "mix/linear_light": {
+        inputs: { fac: F(0.5), a: C([1, 1, 1], true), b: C() },
+        outputs: { color: "color" },
+        emit: (a) => `mix_linear_light(${a.fac}, ${a.a}, ${a.b})`,
+    },
+    // Emission-add: color + scalar-gated emission. Stand-in for Blender's
+    // Emission → Add Shader pair in the ShaderToRGB era (see hair's bright-tex gate).
+    "mix/add_emit": {
+        inputs: { a: C([0, 0, 0], true), b: F(0) },
+        outputs: { color: "color" },
+        emit: (a) => `${a.a} + vec3f(${a.b})`,
+    },
+    // Blender Emission shader: color × strength. In the ShaderToRGB-era ports the
+    // emission result feeds a Mix Shader directly as radiance. Color may be a literal
+    // (body's rim tints) or linked.
+    emission: {
+        inputs: { color: C([1, 1, 1]), strength: F(1) },
+        outputs: { color: "color" },
+        emit: (a) => `${a.color} * ${a.strength}`,
+    },
+    // Blender Add Shader — radiance sum of two evaluated shading results.
+    add_shader: {
+        inputs: { a: C([0, 0, 0], true), b: C([0, 0, 0], true) },
+        outputs: { color: "color" },
+        emit: (a) => `${a.a} + ${a.b}`,
+    },
+    // Mix Shader — plain lerp between two evaluated shading results.
+    mix_shader: {
+        inputs: { fac: F(0.5), a: C([0, 0, 0], true), b: C([0, 0, 0]) },
+        outputs: { color: "color" },
+        emit: (a) => `mix(${a.a}, ${a.b}, ${a.fac})`,
+    },
+    // ── View-dependent scalars ──
+    fresnel: { inputs: { ior: F(1.45) }, outputs: { value: "float" }, emit: (a) => `fresnel(${a.ior}, n, v)` },
+    "layer_weight/fresnel": {
+        inputs: { blend: F(0.5) },
+        outputs: { value: "float" },
+        emit: (a) => `layer_weight_fresnel(${a.blend}, n, v)`,
+    },
+    "layer_weight/facing": {
+        inputs: { blend: F(0.5) },
+        outputs: { value: "float" },
+        emit: (a) => `layer_weight_facing(${a.blend}, n, v)`,
+    },
+    // ── Lighting capture ──
+    shader_to_rgb_diffuse: {
+        inputs: {},
+        outputs: { value: "float" },
+        emit: () => `shader_to_rgb_diffuse(n, l, sun, amb, shadow)`,
+    },
+    // ── Vector ──
+    separate_xyz: {
+        inputs: { vector: V([0, 0, 0], true) },
+        outputs: { x: "float", y: "float", z: "float" },
+        outputSelect: { x: ".x", y: ".y", z: ".z" },
+        emit: (a) => a.vector,
+    },
+    vect_cross: {
+        // b may be a literal constant (metal crosses the reflection dir with (0,1,0)).
+        inputs: { a: V([0, 0, 0], true), b: V([0, 1, 0]) },
+        outputs: { vector: "vector" },
+        emit: (a) => `vect_math_cross(${a.a}, ${a.b})`,
+    },
+    mapping: {
+        inputs: { vector: V([0, 0, 0], true), loc: V([0, 0, 0]), rot: V([0, 0, 0]), scl: V([1, 1, 1]) },
+        outputs: { vector: "vector" },
+        emit: (a) => `mapping_point(${a.vector}, ${a.loc}, ${a.rot}, ${a.scl})`,
+    },
+    bump: {
+        // Screen-space bump; world position comes from context (matches bump_lh's port).
+        inputs: { strength: F(0.1), height: F(0, true), normal: V([0, 0, 0], true) },
+        outputs: { vector: "vector" },
+        emit: (a) => `bump_lh(${a.strength}, ${a.height}, ${a.normal}, input.worldPos)`,
+    },
+    // ── Procedural textures ──
+    tex_noise: {
+        inputs: { vector: V([0, 0, 0], true), scale: F(5), detail: F(2), roughness: F(0.5), distortion: F(0) },
+        outputs: { value: "float" },
+        emit: (a) => `tex_noise(${a.vector}, ${a.scale}, ${a.detail}, ${a.roughness}, ${a.distortion})`,
+    },
+    tex_gradient: {
+        inputs: { vector: V([0, 0, 0], true) },
+        outputs: { value: "float" },
+        emit: (a) => `tex_gradient_linear(${a.vector})`,
+    },
+    "tex_voronoi/f1": {
+        inputs: { vector: V([0, 0, 0], true), scale: F(5) },
+        outputs: { value: "float" },
+        emit: (a) => `tex_voronoi_f1(${a.vector}, ${a.scale})`,
+    },
+    "tex_voronoi/color": {
+        inputs: { vector: V([0, 0, 0], true), scale: F(5) },
+        outputs: { color: "color" },
+        emit: (a) => `tex_voronoi_color(${a.vector}, ${a.scale})`,
+    },
+    // ── Principled BSDF (frozen 3.6 legacy-EEVEE semantics: eval_principled port) ──
+    // normal defaults to the template's shading normal; link a bump/normal_map chain
+    // to perturb it (body/cloth_rough noise bump).
+    principled: {
+        inputs: {
+            base: C([0.8, 0.8, 0.8], true),
+            metallic: F(0),
+            specular: F(0.5),
+            roughness: F(0.5),
+            spec_clamp: F(1e30),
+            sheen: F(0),
+            sheen_tint: F(0),
+            normal: { type: "vector", contextDefault: "n" },
+        },
+        outputs: { color: "color" },
+        emit: (a) => `eval_principled(PrincipledIn(${a.base}, ${a.metallic}, ${a.specular}, ${a.roughness}, ${a.spec_clamp}, ${a.sheen}, ${a.sheen_tint}), ${a.normal}, l, v, sun, amb, shadow)`,
+    },
+};

package/dist/graph/schema.d.ts

@@ -0,0 +1,66 @@
+import type { MaterialPreset } from "../engine";
+export type SocketValue = number | [number, number, number] | [number, number, number, number];
+export type GraphNode = {
+    /** Unique within the graph, /^[a-z0-9_]+$/ — becomes the WGSL variable suffix. */
+    id: string;
+    /** Node registry key, e.g. "hue_sat", "math/power", "mix/blend". */
+    type: string;
+    /** Literal defaults for unlinked input sockets. */
+    inputs?: Record<string, SocketValue>;
+    /** Editor-only metadata (React Flow position). Ignored by the compiler, round-tripped
+     *  by serialization so engine-side tooling never strips an editor's layout. */
+    ui?: {
+        position?: {
+            x: number;
+            y: number;
+        };
+    };
+};
+export type GraphLink = {
+    from: {
+        node: string;
+        socket: string;
+    };
+    to: {
+        node: string;
+        socket: string;
+    };
+};
+/** Adjust-tier slider: overrides one unlinked literal input with a StyleUniforms read. */
+export type ExposedParam = {
+    /** Stable key — slot assignment and serialization identity. */
+    id: string;
+    label: string;
+    target: {
+        node: string;
+        socket: string;
+    };
+    kind: "float" | "color";
+    min?: number;
+    max?: number;
+    default: SocketValue;
+};
+export type StyleGraph = {
+    version: 1;
+    name: string;
+    /** Which preset slot this style targets. The slot owns pass integration (stencil
+     *  variants like hair-over-eyes, alpha semantics, draw order) — always on,
+     *  graph-invisible. The graph only restyles the slot's shading. */
+    slot: MaterialPreset;
+    nodes: GraphNode[];
+    links: GraphLink[];
+    /** Must resolve to a color (vec3f) or float (auto-splatted) socket. */
+    output: {
+        node: string;
+        socket: string;
+    };
+    params?: ExposedParam[];
+};
+export type Diagnostic = {
+    severity: "error" | "warning";
+    nodeId?: string;
+    message: string;
+};
+export declare const MAX_NODES = 64;
+export declare const MAX_PARAMS = 16;
+//# sourceMappingURL=schema.d.ts.map

package/dist/graph/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/graph/schema.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,WAAW,CAAA;AAE/C,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AAE9F,MAAM,MAAM,SAAS,GAAG;IACtB,kFAAkF;IAClF,EAAE,EAAE,MAAM,CAAA;IACV,oEAAoE;IACpE,IAAI,EAAE,MAAM,CAAA;IACZ,mDAAmD;IACnD,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAA;IACpC;mFAC+E;IAC/E,EAAE,CAAC,EAAE;QAAE,QAAQ,CAAC,EAAE;YAAE,CAAC,EAAE,MAAM,CAAC;YAAC,CAAC,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE,CAAA;CAC7C,CAAA;AAED,MAAM,MAAM,SAAS,GAAG;IACtB,IAAI,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAA;IACtC,EAAE,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAA;CACrC,CAAA;AAED,0FAA0F;AAC1F,MAAM,MAAM,YAAY,GAAG;IACzB,+DAA+D;IAC/D,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAA;IACxC,IAAI,EAAE,OAAO,GAAG,OAAO,CAAA;IACvB,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,WAAW,CAAA;CACrB,CAAA;AAED,MAAM,MAAM,UAAU,GAAG;IACvB,OAAO,EAAE,CAAC,CAAA;IACV,IAAI,EAAE,MAAM,CAAA;IACZ;;uEAEmE;IACnE,IAAI,EAAE,cAAc,CAAA;IACpB,KAAK,EAAE,SAAS,EAAE,CAAA;IAClB,KAAK,EAAE,SAAS,EAAE,CAAA;IAClB,uEAAuE;IACvE,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAA;IACxC,MAAM,CAAC,EAAE,YAAY,EAAE,CAAA;CACxB,CAAA;AAED,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAA;IAC7B,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,eAAO,MAAM,SAAS,KAAK,CAAA;AAC3B,eAAO,MAAM,UAAU,KAAK,CAAA"}

package/dist/graph/schema.js

@@ -0,0 +1,6 @@
+// Material style graph — JSON-serializable node graph compiled to WGSL by compile.ts.
+// Engine-space (LH, Y-up): porting a Blender graph converts coordinates at authoring
+// time (Blender Normal Z → engine Y), the compiler never sees Blender conventions.
+// See docs/graph-compiler-spec.md.
+export const MAX_NODES = 64;
+export const MAX_PARAMS = 16;