reze-engine 0.17.1 → 0.18.0

package/src/graph/compile.ts

@@ -0,0 +1,342 @@
+// 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 type { Diagnostic, ExposedParam, GraphNode, SocketValue, StyleGraph } from "./schema"
+import { NODE_REGISTRY, canConvert, convert, fmtValue, literalFits } from "./registry"
+import type { NodeSpec, SockT } from "./registry"
+import { assembleModule } from "./slots"
+
+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[]
+}
+
+const ID_RE = /^[a-z0-9_]+$/
+
+const err = (message: string, nodeId?: string): Diagnostic => ({ severity: "error", nodeId, message })
+const warn = (message: string, nodeId?: string): Diagnostic => ({ 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"] as const
+
+export function assignStyleSlots(params: ExposedParam[]): StyleSlot[] {
+  const slots: StyleSlot[] = []
+  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: StyleGraph, opts: CompileOptions = {}): Diagnostic[] {
+  const d: Diagnostic[] = []
+  const nodes = new Map<string, GraphNode>()
+
+  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<string>()
+  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<string>()
+  const paramTargets = new Set<string>()
+  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: SockT = 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: StyleGraph, opts: CompileOptions = {}): CompileResult {
+  const fail = (diagnostics: Diagnostic[]): CompileResult => ({
+    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: GraphNode): NodeSpec => NODE_REGISTRY[node.type]
+
+  // incoming[nodeId.socket] = producer; outgoing edges for toposort
+  const incoming = new Map<string, { node: string; socket: string }>()
+  const dependsOn = new Map<string, Set<string>>()
+  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<string>()
+  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<string, { param: ExposedParam; slot: StyleSlot }>()
+  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<string, Set<string>>()
+  for (const id of reachable) {
+    const deps = new Set([...dependsOn.get(id)!].filter((dep) => reachable.has(dep)))
+    remaining.set(id, deps)
+  }
+  const order: string[] = []
+  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: string) => `n_${id}`
+  const usesStyle = { current: false }
+
+  type Resolved = { expr: string; literal?: SocketValue }
+
+  // Expression for a producer's output socket, converted to the consumer's type.
+  const outputExpr = (from: { node: string; socket: string }, wantT: SockT): string => {
+    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: GraphNode, socket: string, wantT: SockT): Resolved => {
+    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: GraphNode, args: Record<string, Resolved>): string => {
+    const raw: Record<string, string> = {}
+    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: string[] = []
+  for (const id of order) {
+    const node = nodes.get(id)!
+    const s = spec(node)
+    if (s.contextOutputs) continue
+    const args: Record<string, Resolved> = {}
+    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/src/graph/presets/body.ts

@@ -0,0 +1,103 @@
+// 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.
+
+import type { StyleGraph } from "../schema"
+
+export const BODY_GRAPH: StyleGraph = {
+  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/src/graph/presets/cloth_rough.ts

@@ -0,0 +1,64 @@
+// 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.
+
+import type { StyleGraph } from "../schema"
+
+export const CLOTH_ROUGH_GRAPH: StyleGraph = {
+  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/src/graph/presets/cloth_smooth.ts

@@ -0,0 +1,56 @@
+// 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.
+
+import type { StyleGraph } from "../schema"
+
+export const CLOTH_SMOOTH_GRAPH: StyleGraph = {
+  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/src/graph/presets/default.ts

@@ -0,0 +1,23 @@
+// 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.
+
+import type { StyleGraph } from "../schema"
+
+export const DEFAULT_GRAPH: StyleGraph = {
+  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" },
+}