reze-engine 0.17.1 → 0.18.0

package/dist/graph/compile.d.ts

@@ -0,0 +1,34 @@
+import type { Diagnostic, ExposedParam, StyleGraph } from "./schema";
+export type CompileOptions = {
+    /** Fold exposed params to their defaults as consts (no StyleUniforms binding).
+     *  Used by golden tests and by hosts that don't bind the style buffer. */
+    inlineParams?: boolean;
+    /** Override the graph output with any node's socket — Blender's node-preview
+     *  (Ctrl+Shift+Click viewer) workflow for the editor. */
+    previewNode?: {
+        node: string;
+        socket: string;
+    };
+};
+/** UBO slot for one exposed param: write `value` at style.p[vec4Index] (+ component). */
+export type StyleSlot = {
+    id: string;
+    kind: "float" | "color";
+    vec4Index: number;
+    component?: "x" | "y" | "z" | "w";
+    expr: string;
+};
+export type CompileResult = {
+    ok: boolean;
+    /** Full WGSL module (empty string when !ok). */
+    wgsl: string;
+    /** Just the generated node section — snapshot tests and editor debugging. */
+    fsBody: string;
+    slotMap: StyleSlot[];
+    diagnostics: Diagnostic[];
+    prunedNodes: string[];
+};
+export declare function assignStyleSlots(params: ExposedParam[]): StyleSlot[];
+export declare function validateGraph(graph: StyleGraph, opts?: CompileOptions): Diagnostic[];
+export declare function compileGraph(graph: StyleGraph, opts?: CompileOptions): CompileResult;
+//# sourceMappingURL=compile.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../../src/graph/compile.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAA0B,UAAU,EAAE,MAAM,UAAU,CAAA;AAK5F,MAAM,MAAM,cAAc,GAAG;IAC3B;8EAC0E;IAC1E,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB;6DACyD;IACzD,WAAW,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAA;CAC/C,CAAA;AAED,yFAAyF;AACzF,MAAM,MAAM,SAAS,GAAG;IACtB,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,OAAO,GAAG,OAAO,CAAA;IACvB,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,CAAC,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAA;IACjC,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAED,MAAM,MAAM,aAAa,GAAG;IAC1B,EAAE,EAAE,OAAO,CAAA;IACX,gDAAgD;IAChD,IAAI,EAAE,MAAM,CAAA;IACZ,6EAA6E;IAC7E,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,SAAS,EAAE,CAAA;IACpB,WAAW,EAAE,UAAU,EAAE,CAAA;IACzB,WAAW,EAAE,MAAM,EAAE,CAAA;CACtB,CAAA;AAcD,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,YAAY,EAAE,GAAG,SAAS,EAAE,CAuBpE;AAID,wBAAgB,aAAa,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,GAAE,cAAmB,GAAG,UAAU,EAAE,CAqGxF;AAID,wBAAgB,YAAY,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,GAAE,cAAmB,GAAG,aAAa,CA6JxF"}

package/dist/graph/compile.js

@@ -0,0 +1,299 @@
+// Graph → WGSL compiler: validate → prune → toposort → peephole → emit.
+// Deterministic by construction (topo ties broken by node id, literals formatted by
+// shortest round-trip) so the same graph JSON always yields byte-identical WGSL.
+// See docs/graph-compiler-spec.md.
+import { MAX_NODES, MAX_PARAMS } from "./schema";
+import { NODE_REGISTRY, canConvert, convert, fmtValue, literalFits } from "./registry";
+import { assembleModule } from "./slots";
+const ID_RE = /^[a-z0-9_]+$/;
+const err = (message, nodeId) => ({ severity: "error", nodeId, message });
+const warn = (message, nodeId) => ({ severity: "warning", nodeId, message });
+// ─── Param slot assignment ──────────────────────────────────────────
+// Floats pack 4-per-vec4 in declaration order; colors take .rgb of a fresh vec4.
+// Depends only on the params array, never on graph topology — a topology edit
+// doesn't move slider slots.
+const COMPONENTS = ["x", "y", "z", "w"];
+export function assignStyleSlots(params) {
+    const slots = [];
+    let vec4Index = 0;
+    let comp = 0;
+    for (const p of params) {
+        if (p.kind === "color") {
+            if (comp > 0) {
+                vec4Index++;
+                comp = 0;
+            }
+            slots.push({ id: p.id, kind: "color", vec4Index, expr: `style.p[${vec4Index}].rgb` });
+            vec4Index++;
+        }
+        else {
+            const c = COMPONENTS[comp];
+            slots.push({ id: p.id, kind: "float", vec4Index, component: c, expr: `style.p[${vec4Index}].${c}` });
+            comp++;
+            if (comp === 4) {
+                vec4Index++;
+                comp = 0;
+            }
+        }
+    }
+    return slots;
+}
+// ─── Validation ─────────────────────────────────────────────────────
+export function validateGraph(graph, opts = {}) {
+    const d = [];
+    const nodes = new Map();
+    if (graph.version !== 1)
+        d.push(err(`unsupported graph version: ${graph.version}`));
+    if (graph.nodes.length > MAX_NODES)
+        d.push(err(`graph has ${graph.nodes.length} nodes (max ${MAX_NODES})`));
+    for (const node of graph.nodes) {
+        if (!ID_RE.test(node.id))
+            d.push(err(`invalid node id "${node.id}" (want /^[a-z0-9_]+$/)`, node.id));
+        if (nodes.has(node.id))
+            d.push(err(`duplicate node id "${node.id}"`, node.id));
+        nodes.set(node.id, node);
+        const spec = NODE_REGISTRY[node.type];
+        if (!spec) {
+            d.push(err(`unknown node type "${node.type}"`, node.id));
+            continue;
+        }
+        for (const [socket, value] of Object.entries(node.inputs ?? {})) {
+            const input = spec.inputs[socket];
+            if (!input)
+                d.push(err(`node "${node.id}" (${node.type}) has no input socket "${socket}"`, node.id));
+            else if (!literalFits(value, input.type))
+                d.push(err(`literal for "${node.id}.${socket}" doesn't fit ${input.type} socket`, node.id));
+        }
+    }
+    const linkedInputs = new Set();
+    for (const link of graph.links) {
+        const fromNode = nodes.get(link.from.node);
+        const toNode = nodes.get(link.to.node);
+        if (!fromNode) {
+            d.push(err(`link source node "${link.from.node}" doesn't exist`));
+            continue;
+        }
+        if (!toNode) {
+            d.push(err(`link target node "${link.to.node}" doesn't exist`));
+            continue;
+        }
+        const fromSpec = NODE_REGISTRY[fromNode.type];
+        const toSpec = NODE_REGISTRY[toNode.type];
+        if (!fromSpec || !toSpec)
+            continue; // unknown type already reported
+        const fromT = fromSpec.outputs[link.from.socket];
+        if (!fromT) {
+            d.push(err(`node "${link.from.node}" (${fromNode.type}) has no output socket "${link.from.socket}"`, link.from.node));
+            continue;
+        }
+        const toInput = toSpec.inputs[link.to.socket];
+        if (!toInput) {
+            d.push(err(`node "${link.to.node}" (${toNode.type}) has no input socket "${link.to.socket}"`, link.to.node));
+            continue;
+        }
+        if (toInput.type === "vec4") {
+            d.push(err(`ramp stop colors must be literals — cannot link into "${link.to.node}.${link.to.socket}"`, link.to.node));
+            continue;
+        }
+        if (!canConvert(fromT, toInput.type))
+            d.push(err(`type mismatch: "${link.from.node}.${link.from.socket}" (${fromT}) → "${link.to.node}.${link.to.socket}" (${toInput.type})`, link.to.node));
+        const key = `${link.to.node}.${link.to.socket}`;
+        if (linkedInputs.has(key))
+            d.push(err(`input "${key}" has more than one incoming link`, link.to.node));
+        linkedInputs.add(key);
+    }
+    const params = graph.params ?? [];
+    if (params.length > MAX_PARAMS)
+        d.push(err(`graph exposes ${params.length} params (max ${MAX_PARAMS})`));
+    const paramIds = new Set();
+    const paramTargets = new Set();
+    for (const p of params) {
+        if (paramIds.has(p.id))
+            d.push(err(`duplicate param id "${p.id}"`));
+        paramIds.add(p.id);
+        const node = nodes.get(p.target.node);
+        if (!node) {
+            d.push(err(`param "${p.id}" targets missing node "${p.target.node}"`));
+            continue;
+        }
+        const spec = NODE_REGISTRY[node.type];
+        const input = spec?.inputs[p.target.socket];
+        if (!input) {
+            d.push(err(`param "${p.id}" targets missing socket "${p.target.node}.${p.target.socket}"`, p.target.node));
+            continue;
+        }
+        const key = `${p.target.node}.${p.target.socket}`;
+        if (linkedInputs.has(key))
+            d.push(err(`param "${p.id}" targets linked socket "${key}" — sliders only override literals`, p.target.node));
+        if (paramTargets.has(key))
+            d.push(err(`params target socket "${key}" more than once`, p.target.node));
+        paramTargets.add(key);
+        const wantKind = p.kind === "color" ? "color" : "float";
+        if (input.type !== wantKind)
+            d.push(err(`param "${p.id}" is ${p.kind} but socket "${key}" is ${input.type}`, p.target.node));
+        if (!literalFits(p.default, input.type))
+            d.push(err(`param "${p.id}" default doesn't fit ${input.type}`, p.target.node));
+    }
+    const out = opts.previewNode ?? graph.output;
+    const outNode = nodes.get(out.node);
+    const outSpec = outNode ? NODE_REGISTRY[outNode.type] : undefined;
+    const outT = outSpec?.outputs[out.socket];
+    if (!outT)
+        d.push(err(`output "${out.node}.${out.socket}" doesn't resolve`, out.node));
+    else if (outT === "vec4")
+        d.push(err(`output "${out.node}.${out.socket}" must be color or float`, out.node));
+    return d;
+}
+// ─── Compile ────────────────────────────────────────────────────────
+export function compileGraph(graph, opts = {}) {
+    const fail = (diagnostics) => ({
+        ok: false,
+        wgsl: "",
+        fsBody: "",
+        slotMap: assignStyleSlots(graph.params ?? []),
+        diagnostics,
+        prunedNodes: [],
+    });
+    const diagnostics = validateGraph(graph, opts);
+    if (diagnostics.some((x) => x.severity === "error"))
+        return fail(diagnostics);
+    const nodes = new Map(graph.nodes.map((node) => [node.id, node]));
+    const spec = (node) => NODE_REGISTRY[node.type];
+    // incoming[nodeId.socket] = producer; outgoing edges for toposort
+    const incoming = new Map();
+    const dependsOn = new Map();
+    for (const id of nodes.keys())
+        dependsOn.set(id, new Set());
+    for (const link of graph.links) {
+        incoming.set(`${link.to.node}.${link.to.socket}`, link.from);
+        dependsOn.get(link.to.node).add(link.from.node);
+    }
+    // Prune: reverse-DFS from the (possibly preview-overridden) output.
+    const out = opts.previewNode ?? graph.output;
+    const reachable = new Set();
+    const stack = [out.node];
+    while (stack.length) {
+        const id = stack.pop();
+        if (reachable.has(id))
+            continue;
+        reachable.add(id);
+        for (const dep of dependsOn.get(id))
+            stack.push(dep);
+    }
+    const prunedNodes = [...nodes.keys()].filter((id) => !reachable.has(id)).sort();
+    // requiresLink applies to live nodes only.
+    for (const id of reachable) {
+        const node = nodes.get(id);
+        for (const [socket, input] of Object.entries(spec(node).inputs)) {
+            if (input.requiresLink && !incoming.has(`${id}.${socket}`) && node.inputs?.[socket] === undefined)
+                diagnostics.push(err(`input "${id}.${socket}" must be linked`, id));
+        }
+    }
+    // Exposed params → style slots. Slot assignment is topology-independent; a param
+    // whose target got pruned keeps its slot but has no effect (warning).
+    const params = graph.params ?? [];
+    const slotMap = assignStyleSlots(params);
+    const paramBySocket = new Map();
+    params.forEach((param, i) => {
+        if (!reachable.has(param.target.node))
+            diagnostics.push(warn(`param "${param.id}" targets pruned node "${param.target.node}" — slider has no effect`));
+        paramBySocket.set(`${param.target.node}.${param.target.socket}`, { param, slot: slotMap[i] });
+    });
+    if (diagnostics.some((x) => x.severity === "error"))
+        return fail(diagnostics);
+    // Toposort (Kahn) over reachable nodes; ready set kept sorted for determinism.
+    const remaining = new Map();
+    for (const id of reachable) {
+        const deps = new Set([...dependsOn.get(id)].filter((dep) => reachable.has(dep)));
+        remaining.set(id, deps);
+    }
+    const order = [];
+    const ready = [...remaining.entries()]
+        .filter(([, deps]) => deps.size === 0)
+        .map(([id]) => id)
+        .sort();
+    while (ready.length) {
+        const id = ready.shift();
+        order.push(id);
+        for (const [other, deps] of remaining) {
+            if (deps.delete(id) && deps.size === 0) {
+                ready.push(other);
+                ready.sort();
+            }
+        }
+        remaining.delete(id);
+    }
+    if (remaining.size) {
+        diagnostics.push(err(`cycle through nodes: ${[...remaining.keys()].sort().join(" → ")}`));
+        return fail(diagnostics);
+    }
+    // ── Emit ──
+    const varName = (id) => `n_${id}`;
+    const usesStyle = { current: false };
+    // Expression for a producer's output socket, converted to the consumer's type.
+    const outputExpr = (from, wantT) => {
+        const fromNode = nodes.get(from.node);
+        const fromSpec = spec(fromNode);
+        const fromT = fromSpec.outputs[from.socket];
+        const base = fromSpec.contextOutputs
+            ? fromSpec.contextOutputs[from.socket]
+            : varName(from.node) + (fromSpec.outputSelect?.[from.socket] ?? "");
+        return convert(fromT, wantT, base);
+    };
+    const resolveInput = (node, socket, wantT) => {
+        const key = `${node.id}.${socket}`;
+        const link = incoming.get(key);
+        if (link)
+            return { expr: outputExpr(link, wantT) };
+        const exposed = paramBySocket.get(key);
+        if (exposed && !opts.inlineParams) {
+            usesStyle.current = true;
+            const raw = exposed.slot.expr;
+            return { expr: exposed.param.kind === "float" ? convert("float", wantT, raw) : convert("color", wantT, raw) };
+        }
+        const inputSpec = spec(node).inputs[socket];
+        const value = exposed?.param.default ?? node.inputs?.[socket] ?? inputSpec.default;
+        if (value === undefined) {
+            if (inputSpec.contextDefault)
+                return { expr: inputSpec.contextDefault };
+            throw new Error(`unresolved input ${key}`); // guarded by requiresLink validation
+        }
+        return { expr: fmtValue(value, wantT), literal: value };
+    };
+    // Peephole canonicalizations — fire only on plain literals (unexposed, unlinked),
+    // reproducing the hand-written Safari specializations.
+    const emitExpr = (node, args) => {
+        const raw = {};
+        for (const [k, v] of Object.entries(args))
+            raw[k] = v.expr;
+        if (node.type === "hue_sat" && args.hue.literal === 0.5)
+            return `hue_sat_id(${raw.saturation}, ${raw.value}, ${raw.fac}, ${raw.color})`;
+        if (node.type.startsWith("mix/") && node.type !== "mix/add_emit") {
+            if (args.fac.literal === 0)
+                return raw.a;
+            if (node.type === "mix/blend" && args.fac.literal === 1)
+                return raw.b;
+        }
+        if (node.type === "tex_noise" &&
+            args.detail.literal === 2 &&
+            args.roughness.literal === 0.5 &&
+            args.distortion.literal === 0)
+            return `tex_noise_d2(${raw.vector}, ${raw.scale})`;
+        return spec(node).emit(raw);
+    };
+    const lines = [];
+    for (const id of order) {
+        const node = nodes.get(id);
+        const s = spec(node);
+        if (s.contextOutputs)
+            continue;
+        const args = {};
+        for (const [socket, input] of Object.entries(s.inputs))
+            args[socket] = resolveInput(node, socket, input.type);
+        lines.push(`  let ${varName(id)} = ${emitExpr(node, args)}; // @node:${id}`);
+    }
+    lines.push(`  let final_color = ${outputExpr(out, "color")}; // @node:${out.node}`);
+    const fsBody = lines.join("\n");
+    const wgsl = assembleModule(graph.slot, fsBody, usesStyle.current);
+    return { ok: true, wgsl, fsBody, slotMap, diagnostics, prunedNodes };
+}

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

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

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

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

package/dist/graph/presets/body.js

@@ -0,0 +1,100 @@
+// M_Body as a StyleGraph — port of shaders/materials/body.ts (仿深空之眼 "M_Body").
+// Toon + warm rim + rim1/rim2 stack mixed 50/50 against a Principled BSDF with
+// noise-bumped normal. The hand port's local ramp_ease is ramp_cardinal (identical
+// smoothstep form); the Mapping node's zero loc/rot folds to a scale multiply.
+export const BODY_GRAPH = {
+    version: 1,
+    name: "Body",
+    slot: "body",
+    nodes: [
+        { id: "tex", type: "texture" },
+        { id: "geo", type: "geometry" },
+        { id: "str", type: "shader_to_rgb_diffuse" },
+        { id: "toon", type: "ramp_constant", inputs: { pos0: 0.0, pos1: 0.2966 } },
+        { id: "shadow_tint", type: "hue_sat", inputs: { hue: 0.5, saturation: 2.0, value: 0.3499999940395355, fac: 1.0 } },
+        { id: "lit_tint", type: "hue_sat", inputs: { hue: 0.5, saturation: 1.5, value: 1.0, fac: 1.0 } },
+        { id: "toon_color", type: "mix/blend" },
+        { id: "bc", type: "bright_contrast", inputs: { bright: 0.1, contrast: 0.2 } },
+        { id: "emission3", type: "emission", inputs: { strength: 4.0 } },
+        { id: "warm_add", type: "math/add", inputs: { b: 0.5 } },
+        { id: "warm_clamp", type: "math/clamp01" },
+        {
+            id: "warm_ramp",
+            type: "ramp_cardinal",
+            inputs: {
+                pos0: 0.2409,
+                color0: [0.2426, 0.068, 0.0588, 1.0],
+                pos1: 0.4663,
+                color1: [0.6677, 0.5024, 0.5126, 1.0],
+            },
+        },
+        { id: "warm_emit", type: "emission", inputs: { strength: 0.30000001192092896 } },
+        { id: "rim1_fres", type: "fresnel", inputs: { ior: 2.0 } },
+        { id: "rim1_lw", type: "layer_weight/facing", inputs: { blend: 0.24000005424022675 } },
+        { id: "rim1_str", type: "math/multiply" },
+        { id: "rim1", type: "emission", inputs: { color: [0.984157919883728, 0.6110184788703918, 0.5736401677131653] } },
+        { id: "rim2_lw", type: "layer_weight/facing", inputs: { blend: 0.20000000298023224 } },
+        { id: "rim2_pow", type: "math/power", inputs: { b: 1.4300000667572021 } },
+        { id: "rim2_ramp", type: "ramp_cardinal", inputs: { pos0: 0.0, pos1: 0.5052 } },
+        { id: "rim2_mix", type: "mix_shader", inputs: { b: [1.0, 0.4303792119026184, 0.3315804898738861] } },
+        { id: "npr_add1", type: "add_shader" },
+        { id: "npr_stack", type: "add_shader" },
+        { id: "map", type: "mapping", inputs: { scl: [1.0, 1.0, 1.5] } },
+        { id: "noise", type: "tex_noise", inputs: { scale: 1.0 } },
+        { id: "noise_ramp", type: "ramp_linear", inputs: { pos0: 0.0, pos1: 1.0 } },
+        { id: "bump", type: "bump", inputs: { strength: 0.324644535779953 } },
+        {
+            id: "principled_base",
+            type: "mix/blend",
+            inputs: { b: [0.6831911206245422, 0.19474034011363983, 0.13732507824897766] },
+        },
+        { id: "p_emit", type: "emission", inputs: { strength: 0.2 } },
+        {
+            id: "principled",
+            type: "principled",
+            inputs: { metallic: 0.0, specular: 0.5, roughness: 0.3, spec_clamp: 10.0, sheen: 0.0, sheen_tint: 0.0 },
+        },
+        { id: "p_sum", type: "add_shader" },
+        { id: "mix_shader_001", type: "mix_shader", inputs: { fac: 0.5 } },
+    ],
+    links: [
+        { from: { node: "str", socket: "value" }, to: { node: "toon", socket: "fac" } },
+        { from: { node: "tex", socket: "color" }, to: { node: "shadow_tint", socket: "color" } },
+        { from: { node: "tex", socket: "color" }, to: { node: "lit_tint", socket: "color" } },
+        { from: { node: "toon", socket: "fac_out" }, to: { node: "toon_color", socket: "fac" } },
+        { from: { node: "shadow_tint", socket: "color" }, to: { node: "toon_color", socket: "a" } },
+        { from: { node: "lit_tint", socket: "color" }, to: { node: "toon_color", socket: "b" } },
+        { from: { node: "toon_color", socket: "color" }, to: { node: "bc", socket: "color" } },
+        { from: { node: "bc", socket: "color" }, to: { node: "emission3", socket: "color" } },
+        { from: { node: "toon", socket: "fac_out" }, to: { node: "warm_add", socket: "a" } },
+        { from: { node: "warm_add", socket: "value" }, to: { node: "warm_clamp", socket: "a" } },
+        { from: { node: "warm_clamp", socket: "value" }, to: { node: "warm_ramp", socket: "fac" } },
+        { from: { node: "warm_ramp", socket: "color" }, to: { node: "warm_emit", socket: "color" } },
+        { from: { node: "rim1_fres", socket: "value" }, to: { node: "rim1_str", socket: "a" } },
+        { from: { node: "rim1_lw", socket: "value" }, to: { node: "rim1_str", socket: "b" } },
+        { from: { node: "rim1_str", socket: "value" }, to: { node: "rim1", socket: "strength" } },
+        { from: { node: "rim2_lw", socket: "value" }, to: { node: "rim2_pow", socket: "a" } },
+        { from: { node: "rim2_pow", socket: "value" }, to: { node: "rim2_ramp", socket: "fac" } },
+        { from: { node: "emission3", socket: "color" }, to: { node: "rim2_mix", socket: "a" } },
+        { from: { node: "rim2_ramp", socket: "fac_out" }, to: { node: "rim2_mix", socket: "fac" } },
+        { from: { node: "rim1", socket: "color" }, to: { node: "npr_add1", socket: "a" } },
+        { from: { node: "rim2_mix", socket: "color" }, to: { node: "npr_add1", socket: "b" } },
+        { from: { node: "npr_add1", socket: "color" }, to: { node: "npr_stack", socket: "a" } },
+        { from: { node: "warm_emit", socket: "color" }, to: { node: "npr_stack", socket: "b" } },
+        { from: { node: "geo", socket: "rest_pos" }, to: { node: "map", socket: "vector" } },
+        { from: { node: "map", socket: "vector" }, to: { node: "noise", socket: "vector" } },
+        { from: { node: "noise", socket: "value" }, to: { node: "noise_ramp", socket: "fac" } },
+        { from: { node: "noise_ramp", socket: "fac_out" }, to: { node: "bump", socket: "height" } },
+        { from: { node: "geo", socket: "normal" }, to: { node: "bump", socket: "normal" } },
+        { from: { node: "noise_ramp", socket: "fac_out" }, to: { node: "principled_base", socket: "fac" } },
+        { from: { node: "bc", socket: "color" }, to: { node: "principled_base", socket: "a" } },
+        { from: { node: "bc", socket: "color" }, to: { node: "p_emit", socket: "color" } },
+        { from: { node: "principled_base", socket: "color" }, to: { node: "principled", socket: "base" } },
+        { from: { node: "bump", socket: "vector" }, to: { node: "principled", socket: "normal" } },
+        { from: { node: "principled", socket: "color" }, to: { node: "p_sum", socket: "a" } },
+        { from: { node: "p_emit", socket: "color" }, to: { node: "p_sum", socket: "b" } },
+        { from: { node: "npr_stack", socket: "color" }, to: { node: "mix_shader_001", socket: "a" } },
+        { from: { node: "p_sum", socket: "color" }, to: { node: "mix_shader_001", socket: "b" } },
+    ],
+    output: { node: "mix_shader_001", socket: "color" },
+};

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

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

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

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

package/dist/graph/presets/cloth_rough.js

@@ -0,0 +1,61 @@
+// M_Rough_Cloth as a StyleGraph — port of shaders/materials/cloth_rough.ts.
+// NPR graph identical to M_Smooth_Cloth, but the noise bump subtree IS live on
+// Principled.Normal (weave bump in rest space) and Roughness is raised to 0.8187.
+// The tex_noise node hits the detail=2 peephole → tex_noise_d2.
+export const CLOTH_ROUGH_GRAPH = {
+    version: 1,
+    name: "Rough Cloth",
+    slot: "cloth_rough",
+    nodes: [
+        { id: "tex", type: "texture" },
+        { id: "geo", type: "geometry" },
+        { 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: "sep_n", type: "separate_xyz" },
+        { id: "bevel_clamp", type: "math/clamp01" },
+        { id: "mix_003", type: "mix/blend" },
+        { id: "hue_004", type: "hue_sat", inputs: { hue: 0.5, saturation: 0.800000011920929, value: 2.0, fac: 1.0 } },
+        { id: "npr_overlay", type: "mix/overlay", inputs: { fac: 1.0 } },
+        { id: "npr_emit", type: "emission", inputs: { strength: 18.200000762939453 } },
+        { id: "noise", type: "tex_noise", inputs: { scale: 17.7 } },
+        { id: "noise_ramp", type: "ramp_linear", inputs: { pos0: 0.0, pos1: 1.0 } },
+        { id: "bump", type: "bump", inputs: { strength: 1.0 } },
+        { id: "principled_base", type: "hue_sat", inputs: { hue: 0.5, saturation: 1.0, value: 0.800000011920929, fac: 1.0 } },
+        {
+            id: "principled",
+            type: "principled",
+            inputs: { metallic: 0.0, specular: 0.8, roughness: 0.8187, spec_clamp: 10.0, sheen: 0.0, sheen_tint: 0.0 },
+        },
+        { id: "mix_shader_001", type: "mix_shader", inputs: { fac: 0.8999999761581421 } },
+    ],
+    links: [
+        { 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", 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", socket: "color" }, to: { node: "mix_004", socket: "b" } },
+        { 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: "mix_004", socket: "color" }, to: { node: "mix_003", socket: "a" } },
+        { from: { node: "dark_tex", socket: "color" }, to: { node: "mix_003", socket: "b" } },
+        { from: { node: "mix_003", socket: "color" }, to: { node: "hue_004", socket: "color" } },
+        { from: { node: "mix_003", 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: "rest_pos" }, to: { node: "noise", socket: "vector" } },
+        { from: { node: "noise", socket: "value" }, to: { node: "noise_ramp", socket: "fac" } },
+        { from: { node: "noise_ramp", socket: "fac_out" }, to: { node: "bump", socket: "height" } },
+        { from: { node: "geo", socket: "normal" }, to: { node: "bump", socket: "normal" } },
+        { from: { node: "tex", socket: "color" }, to: { node: "principled_base", socket: "color" } },
+        { from: { node: "principled_base", socket: "color" }, to: { node: "principled", socket: "base" } },
+        { from: { node: "bump", socket: "vector" }, to: { node: "principled", socket: "normal" } },
+        { 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/cloth_smooth.d.ts

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

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

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

package/dist/graph/presets/cloth_smooth.js

@@ -0,0 +1,53 @@
+// M_Smooth_Cloth as a StyleGraph — port of shaders/materials/cloth_smooth.ts.
+// NPR toon + bevel + overlay-boosted emission (18.2×) mixed 10/90 against a plain
+// Principled BSDF. The Blender graph's dead bump subtree is omitted (as in the hand
+// port). hue_sat nodes with hue=0.5 compile to the hue_sat_id specialization.
+export const CLOTH_SMOOTH_GRAPH = {
+    version: 1,
+    name: "Smooth Cloth",
+    slot: "cloth_smooth",
+    nodes: [
+        { id: "tex", type: "texture" },
+        { id: "geo", type: "geometry" },
+        { 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: "sep_n", type: "separate_xyz" },
+        { id: "bevel_clamp", type: "math/clamp01" },
+        { id: "mix_003", type: "mix/blend" },
+        { id: "hue_004", type: "hue_sat", inputs: { hue: 0.5, saturation: 0.800000011920929, value: 2.0, fac: 1.0 } },
+        { id: "npr_overlay", type: "mix/overlay", inputs: { fac: 1.0 } },
+        { id: "npr_emit", type: "emission", inputs: { strength: 18.200000762939453 } },
+        { id: "principled_base", type: "hue_sat", inputs: { hue: 0.5, saturation: 1.0, value: 0.800000011920929, fac: 1.0 } },
+        {
+            id: "principled",
+            type: "principled",
+            inputs: { metallic: 0.0, specular: 0.8, roughness: 0.5, spec_clamp: 10.0, sheen: 0.0, sheen_tint: 0.0 },
+        },
+        { id: "mix_shader_001", type: "mix_shader", inputs: { fac: 0.8999999761581421 } },
+    ],
+    links: [
+        { 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", 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", socket: "color" }, to: { node: "mix_004", socket: "b" } },
+        { 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: "mix_004", socket: "color" }, to: { node: "mix_003", socket: "a" } },
+        { from: { node: "dark_tex", socket: "color" }, to: { node: "mix_003", socket: "b" } },
+        { from: { node: "mix_003", socket: "color" }, to: { node: "hue_004", socket: "color" } },
+        { from: { node: "mix_003", 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: "tex", socket: "color" }, to: { node: "principled_base", socket: "color" } },
+        { from: { node: "principled_base", 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/default.d.ts

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

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

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

package/dist/graph/presets/default.js

@@ -0,0 +1,20 @@
+// Default material as a StyleGraph — Blender's new-material template verbatim:
+// Image Texture → Principled BSDF (Metallic 0, Specular 0.5, Roughness 0.5) → Output.
+// This is both the port of shaders/materials/default.ts (must match it pixel-for-pixel;
+// see tests/graph.test.mjs) and the blank-canvas starter graph an editor offers when
+// the user creates a new style.
+export const DEFAULT_GRAPH = {
+    version: 1,
+    name: "Principled BSDF",
+    slot: "default",
+    nodes: [
+        { id: "tex", type: "texture" },
+        {
+            id: "principled",
+            type: "principled",
+            inputs: { metallic: 0.0, specular: 0.5, roughness: 0.5, spec_clamp: 10.0, sheen: 0.0, sheen_tint: 0.0 },
+        },
+    ],
+    links: [{ from: { node: "tex", socket: "color" }, to: { node: "principled", socket: "base" } }],
+    output: { node: "principled", socket: "color" },
+};

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

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

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

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