@womp/spark-agent 8.0.0 → 9.1.0

package/dist/materials/flowir.js

@@ -0,0 +1,362 @@
+import * as flowir from "@womp/flowir";
+import dialect from "./schemas/materials-dialect.json" with { type: "json" };
+import { formatBoundedDiagnostics } from "../geometry/diagnostics.js";
+import { makeMaterialNode, validateMaterialGraph, value3 } from "./graph.js";
+export const materialFlowirRegistry = flowir.Registry.fromJsonObject(dialect);
+export const materialDialectNames = {
+    InputMaterial: "IncomingMaterial", Noise1D: "ScalarNoise", Noise3D: "VectorNoise",
+};
+export const materialScalarMathOperations = ["ScalarAdd", "ScalarSubtract", "ScalarMultiply", "ScalarDivide"];
+function normalizeLegacyProgram(program) {
+    const types = new Map(program.statements.flatMap(statement => statement.kind === "node" ? [[statement.id, statement.nodeType]] : []));
+    const value = (item) => {
+        if ((item.kind === "ref" || item.kind === "float_ref") && types.get(item.nodeId) === "BrickTexture")
+            item.port = { Bricks: "Variation", Mortar: "MortarMask" }[item.port] ?? item.port;
+        if (item.kind === "vec3ctor")
+            [item.x, item.y, item.z].forEach(value);
+        if (item.kind === "float_binop") {
+            value(item.left);
+            value(item.right);
+        }
+    };
+    for (const statement of program.statements) {
+        if (statement.kind !== "node")
+            continue;
+        statement.nodeType = materialDialectNames[statement.nodeType] ?? statement.nodeType;
+        const ports = ["ScalarNoise", "VectorNoise", "NoiseFBM"].includes(statement.nodeType)
+            ? { Scale: "FrequencyScale", NoiseScale: "Amplitude" }
+            : statement.nodeType === "WavesTexture" ? { CoordinateScale: "FrequencyScale", Scale: "Amplitude" }
+                : statement.nodeType === "CheckerTexture" ? { CoordinateScale: "FrequencyScale" }
+                    : statement.nodeType === "BrickTexture" ? { Scale: "FrequencyScale" } : {};
+        statement.inputs = statement.inputs.filter(input => statement.nodeType !== "PredefinedTexture" || input.name !== "Coarseness");
+        for (const input of statement.inputs) {
+            input.name = ports[input.name] ?? input.name;
+            value(input.value);
+        }
+    }
+}
+let prompt;
+export function materialFlowirReference() {
+    prompt ??= flowir.renderPrompt(materialFlowirRegistry);
+    return prompt;
+}
+export const materialMathOperations = [
+    "MathAdd", "MathSubtract", "MathMultiply", "MathDivide", "", "MathPower",
+    "MathSine", "MathCosine", "MathAbsoluteValue", "MathLength", "MathFraction",
+    "MathModulo", "MathFloor", "MathMin", "MathMax", "MathDotProduct",
+    "MathNormalize", "MathDistance", "MathSnap", "MathPingPong", "MathTangent",
+    "MathArcsine", "MathArccosine", "MathArctangent", "MathArctan2",
+];
+const enumLabels = {
+    Mix: "Base", Chebyshev: "Chebychev", Minkowski: "Minkowsky",
+    LessOrEqual: "Less of equal", GreaterOrEqual: "Greater of equal",
+    Raw: "No transform", SRGB: "sRGB (Color)", NormalMap: "Normal",
+};
+const normalized = (value) => value.toLowerCase().replace(/[^a-z0-9]/g, "");
+function checkPort(type, native, label) {
+    const numeric = type === "Vec3" ? ["Float3", "Color"] : type === "Float" ? ["Float"] :
+        type === "Int" ? ["Integer"] : type === "Bool" ? ["Boolean"] : [];
+    if (materialFlowirRegistry.isEnum(type)) {
+        const expected = materialFlowirRegistry.getEnumValues(type);
+        if (native.type !== "Enum" || expected.some((value, index) => normalized(enumLabels[value] ?? value) !== normalized(native.values?.[index] ?? "")))
+            throw new Error(`Kakapo enum contract differs for ${label}`);
+    }
+    else if (!numeric.includes(native.type))
+        throw new Error(`Kakapo port contract differs for ${label}`);
+}
+export function comparableMaterialGraph(graph) {
+    const indices = new Map();
+    const literals = new Map();
+    const nodes = graph.nodes.flatMap((node, index) => {
+        if (node.op === "Options")
+            return [];
+        indices.set(index, indices.size);
+        const copy = { ...node };
+        delete copy.reference_id;
+        delete copy.location;
+        delete copy.editor_flags;
+        if (copy.op === "Passthrough" && !graph.connections.some(edge => edge.output_node === index)) {
+            literals.set(index, 0);
+            delete copy.name;
+        }
+        else if (copy.op === "Constant" && (copy.in3?.x ?? 0) === 0) {
+            const slots = new Set(graph.connections.filter(edge => edge.input_node === index).map(edge => edge.input_slot));
+            const slot = slots.size === 1 ? [...slots][0] : undefined;
+            if (slot === 1 || slot === 2) {
+                literals.set(index, slot);
+                return [{ op: "Passthrough", in0: copy[`in${slot}`] ?? value3(0) }];
+            }
+        }
+        if (copy.op === "PredefinedTexture") {
+            delete copy.in1;
+            delete copy.in2;
+            delete copy.in3; // Native sampling does not use Coarseness.
+        }
+        if (copy.op === "Constant" && copy.in3?.x === 2) {
+            copy.in2 = copy.in1;
+            delete copy.in1;
+            copy.in3 = value3(1);
+        }
+        return [copy];
+    });
+    const connections = graph.connections.map(edge => ({
+        input_node: indices.get(edge.input_node),
+        input_slot: literals.has(edge.input_node) ? 0 : graph.nodes[edge.input_node]?.op === "Constant" &&
+            graph.nodes[edge.input_node].in3?.x === 2 && edge.input_slot === 1
+            ? 2 : edge.input_slot,
+        output_node: indices.get(edge.output_node), output_slot: edge.output_slot,
+        flags: edge.flags ?? 0,
+    })).sort((a, b) => (a.output_node - b.output_node) || (a.output_slot - b.output_slot));
+    return JSON.stringify({ nodes, connections }, (_key, value) => value && typeof value === "object" && !Array.isArray(value)
+        ? Object.fromEntries(Object.entries(value).sort(([a], [b]) => a.localeCompare(b))) : value);
+}
+function vector(value) {
+    if (typeof value === "number")
+        return value3(value);
+    return { x: value[0], y: value[1], z: value[2] };
+}
+export function materialPortSlot(nodeType, name, index) {
+    if (materialMathOperations.includes(nodeType) ||
+        materialScalarMathOperations.includes(nodeType))
+        return name === "Clamp" ? 3 : index + 1;
+    if (nodeType === "OutputHeight" && name === "Scale")
+        return 2;
+    if (nodeType === "ColorRamp" && name === "Mode")
+        return 3;
+    if (nodeType === "PredefinedTexture")
+        return { Coordinates: 0, Coarseness: 3, Transform: 4, DisableFiltering: 5 }[name] ?? -1;
+    if (nodeType === "ProjectionModeSelector")
+        return -1;
+    return index;
+}
+function primitive(value, type) {
+    if (value.kind === "float" || value.kind === "int")
+        return value.value;
+    if (value.kind === "bool")
+        return value.value ? 1 : 0;
+    if (value.kind === "vec3")
+        return vector(value.value);
+    if (value.kind === "string")
+        return value.value;
+    if (value.kind === "ident") {
+        const index = materialFlowirRegistry.getEnumValues(type).indexOf(value.name);
+        if (index >= 0)
+            return index;
+    }
+    return null;
+}
+export function compileMaterialFlowir(source, catalog) {
+    const parsed = flowir.parseIRText(source);
+    if (!parsed.ok)
+        throw new Error(formatBoundedDiagnostics(source, parsed.diagnostics));
+    normalizeLegacyProgram(parsed.program);
+    const checked = flowir.compileFromProgram(parsed.program, materialFlowirRegistry);
+    if (!checked.ok)
+        throw new Error(formatBoundedDiagnostics(source, checked.diagnostics));
+    const graph = { nodes: [], connections: [] };
+    const symbols = {};
+    const values = new Map();
+    const add = (node) => graph.nodes.push(node) - 1;
+    const connect = (from, to, slot) => graph.connections.push({
+        input_node: from.node, input_slot: from.slot, output_node: to, output_slot: slot,
+    });
+    const literal = (value, type) => {
+        const result = primitive(value, type);
+        if (result === null)
+            throw new Error(`Line ${value.line}: ${type} requires a literal value`);
+        return result;
+    };
+    const resolve = (value) => {
+        if (value.kind === "ref") {
+            const found = values.get(`${value.nodeId}.${value.port}`);
+            if (!found)
+                throw new Error(`Line ${value.line}: unresolved ${value.nodeId}.${value.port}`);
+            return found;
+        }
+        if (value.kind === "ident") {
+            const found = values.get(value.name);
+            if (found)
+                return found;
+        }
+        throw new Error(`Line ${value.line}: expected a node output or parameter`);
+    };
+    const expression = (expr) => {
+        if (expr.kind === "float_ident") {
+            const found = values.get(expr.name);
+            if (!found)
+                throw new Error(`Line ${expr.line}: unresolved ${expr.name}`);
+            return found;
+        }
+        if (expr.kind === "float_ref") {
+            const found = values.get(`${expr.nodeId}.${expr.port}`);
+            if (!found)
+                throw new Error(`Line ${expr.line}: unresolved ${expr.nodeId}.${expr.port}`);
+            return found;
+        }
+        if (expr.kind === "float_lit") {
+            const id = add(makeMaterialNode({ op: "Passthrough", inputs: { "0": expr.value } }));
+            return { node: id, slot: 0, type: "Float" };
+        }
+        const op = { "+": 0, "-": 1, "*": 2, "/": 3 }[expr.op];
+        const id = add(makeMaterialNode({ op: "Math", inputs: { "0": op } }));
+        connect(expression(expr.left), id, 1);
+        connect(expression(expr.right), id, 2);
+        return { node: id, slot: 0, type: "Float" };
+    };
+    const attach = (value, type, to, slot, output) => {
+        if (value.kind === "ref" || (value.kind === "ident" && values.has(value.name))) {
+            const from = resolve(value);
+            if (from.type === "Float" && type === "Vec3" &&
+                (value.kind === "ident" || catalog[graph.nodes[from.node].op]?.outputs[from.slot]?.type === "Float3")) {
+                const combined = add(makeMaterialNode({ op: "CombineValues" }));
+                for (let axis = 0; axis < 3; axis++)
+                    connect(from, combined, axis);
+                connect({ node: combined, slot: 0, type: "Vec3" }, to, slot);
+            }
+            else
+                connect(from, to, slot);
+            return;
+        }
+        if (value.kind === "vec3ctor") {
+            const combined = add(makeMaterialNode({ op: "CombineValues" }));
+            for (const [axis, component] of [value.x, value.y, value.z].entries())
+                connect(expression(component), combined, axis);
+            connect({ node: combined, slot: 0, type: "Vec3" }, to, slot);
+            return;
+        }
+        const raw = literal(value, type);
+        if (typeof raw === "string")
+            throw new Error(`Line ${value.line}: string is only valid for Texture`);
+        if (output) {
+            const passthrough = add(makeMaterialNode({ op: "Passthrough", inputs: { "0": raw } }));
+            connect({ node: passthrough, slot: 0, type }, to, slot);
+        }
+        else
+            graph.nodes[to][`in${slot}`] = typeof raw === "number" ? vector(raw) : raw;
+    };
+    const outputs = new Set();
+    for (const statement of parsed.program.statements) {
+        if (statement.kind === "param" || statement.kind === "const") {
+            const color = statement.typeName === "Vec3";
+            const raw = literal(statement.value, statement.typeName);
+            if (typeof raw === "string")
+                throw new Error(`Line ${statement.line}: invalid parameter value`);
+            const node = makeMaterialNode({ op: "Constant", name: statement.name, inputs: {
+                    [color ? "2" : "1"]: raw,
+                    "3": statement.kind === "const" ? 0 : color ? 1 : 3,
+                    ...(statement.kind === "param" && statement.range.min !== null && statement.range.max !== null
+                        ? { "4": { x: statement.range.min, y: statement.range.max, z: statement.range.step ?? 0 } }
+                        : {}),
+                } });
+            const id = add(node);
+            symbols[`$${statement.name}`] = id;
+            values.set(statement.name, { node: id, slot: color ? 2 : 1, type: statement.typeName });
+            continue;
+        }
+        if (statement.kind !== "node")
+            throw new Error(`Line ${statement.line}: material programs do not use out statements`);
+        const schema = materialFlowirRegistry.getNode(statement.nodeType);
+        if (schema.type.startsWith("Output")) {
+            if (outputs.has(schema.type))
+                throw new Error(`Line ${statement.line}: duplicate ${schema.type}`);
+            outputs.add(schema.type);
+        }
+        if (!catalog[schema.type])
+            throw new Error(`Kakapo does not support ${schema.type}`);
+        const id = add(makeMaterialNode({ op: schema.type, name: statement.id }));
+        symbols[statement.id] = id;
+        const node = graph.nodes[id];
+        const scalarMath = materialScalarMathOperations.indexOf(statement.nodeType);
+        if (schema.type === "Math") {
+            const operation = scalarMath >= 0 ? scalarMath : materialMathOperations.indexOf(statement.nodeType);
+            const expected = operation === 2 ? "Mulitiply" : materialMathOperations[operation]?.slice(4);
+            if (operation < 0 || normalized(catalog.Math?.inputs[0]?.values?.[operation] ?? "") !== normalized(expected ?? ""))
+                throw new Error(`Kakapo does not support ${statement.nodeType}`);
+            node.in0 = value3(operation);
+        }
+        const bindings = new Map(statement.inputs.map(input => [input.name, input.value]));
+        for (const [index, port] of schema.inputs.entries()) {
+            const value = bindings.get(port.name);
+            if (!value)
+                continue;
+            if (port.literal && (value.kind === "ref" || (value.kind === "ident" && values.has(value.name))))
+                throw new Error(`Line ${value.line}: ${statement.nodeType}.${port.name} requires a literal`);
+            if (statement.nodeType === "ColorRamp" && /^Position[1-4]$|^Color[1-4]$/.test(port.name))
+                continue;
+            if (statement.nodeType === "ProjectionModeSelector")
+                continue;
+            if (statement.nodeType === "PredefinedTexture" && port.name === "Texture")
+                continue;
+            const slot = materialPortSlot(statement.nodeType, port.name, index);
+            if (slot < 0 || slot >= catalog[schema.type].inputs.length)
+                throw new Error(`Kakapo has no port for ${statement.nodeType}.${port.name}`);
+            checkPort(scalarMath >= 0 && port.type === "Float" ? "Vec3" : port.type, catalog[schema.type].inputs[slot], `${statement.nodeType}.${port.name}`);
+            attach(value, port.type, id, slot, schema.type === "OutputMaterial" || schema.type === "OutputSurfaceNormal");
+            if (statement.nodeType === "Projection" && port.name === "Mode" && value.kind === "ref")
+                node.in5 = value3(1);
+        }
+        if (statement.nodeType === "ColorRamp") {
+            const ramp = [];
+            for (let i = 1; i <= 4; i++) {
+                const position = bindings.get(`Position${i}`), color = bindings.get(`Color${i}`);
+                if (!!position !== !!color)
+                    throw new Error(`Line ${statement.line}: ramp stop ${i} needs position and color`);
+                if (position && color) {
+                    const p = literal(position, "Float"), c = literal(color, "Vec3");
+                    if (typeof p !== "number" || typeof c !== "object")
+                        throw new Error(`Line ${statement.line}: invalid ramp stop ${i}`);
+                    ramp.push({ position: p, color: c });
+                }
+            }
+            Object.assign(node, makeMaterialNode({ op: "ColorRamp", ramp }));
+        }
+        if (statement.nodeType === "ProjectionModeSelector") {
+            if (bindings.has("Option4") && !bindings.has("Option3"))
+                throw new Error(`Line ${statement.line}: Option4 requires Option3`);
+            const options = [];
+            for (let i = 1; i <= 4; i++) {
+                const option = bindings.get(`Option${i}`);
+                if (option) {
+                    const choice = literal(option, "ProjectionMode");
+                    if (typeof choice !== "number")
+                        throw new Error(`Line ${option.line}: invalid projection mode`);
+                    options.push({ name: materialFlowirRegistry.getEnumValues("ProjectionMode")[choice], value: choice });
+                }
+            }
+            const selected = bindings.get("Selected");
+            const choice = selected ? literal(selected, "Int") : 1;
+            if (typeof choice !== "number" || !Number.isInteger(choice) || choice < 1 || choice > options.length)
+                throw new Error(`Line ${statement.line}: Selected must name an option within 1..${options.length}`);
+            Object.assign(node, makeMaterialNode({ op: "OptionSelector", options, inputs: { "1": choice - 1 } }));
+        }
+        if (statement.nodeType === "PredefinedTexture") {
+            const texture = bindings.get("Texture");
+            if (!texture || texture.kind !== "string")
+                throw new Error(`Line ${statement.line}: Texture requires a path string`);
+            Object.assign(node, makeMaterialNode({ op: "PredefinedTexture", texture: texture.value }));
+        }
+        for (const [index, port] of schema.outputs.entries())
+            values.set(`${statement.id}.${port.name}`, { node: id, slot: index, type: port.type });
+    }
+    if (outputs.size === 0)
+        throw new Error("Material program needs an Output node");
+    const validated = validateMaterialGraph(graph, catalog);
+    const depths = new Map();
+    const depth = (index) => {
+        const known = depths.get(index);
+        if (known !== undefined)
+            return known;
+        const inputs = validated.connections.filter(edge => edge.output_node === index);
+        const result = inputs.length ? Math.max(...inputs.map(edge => depth(edge.input_node))) + 1 : 0;
+        depths.set(index, result);
+        return result;
+    };
+    const rows = new Map();
+    validated.nodes.forEach((node, index) => {
+        const column = depth(index);
+        const row = rows.get(column) ?? 0;
+        node.location = { x: column * 250, y: row * 150 };
+        rows.set(column, row + 1);
+    });
+    return { graph: validated, symbols };
+}

package/dist/materials/graph.d.ts

@@ -71,6 +71,13 @@ export declare const writeSchema: z.ZodObject<{
     }, z.core.$strict>>>>;
     objectIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
 }, z.core.$strict>;
+export declare const programWriteSchema: z.ZodObject<{
+    materialId: z.ZodOptional<z.ZodNumber>;
+    cloneFrom: z.ZodOptional<z.ZodNumber>;
+    layerIndex: z.ZodNumber;
+    source: z.ZodString;
+    objectIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+}, z.core.$strict>;
 export declare const value3: (value: number) => MaterialVector;
 export declare function makeMaterialNode(options: MaterialNodeOptions): MaterialNode;
 export declare function parseMaterialCatalog(value: unknown): Record<string, MaterialNodeDescription>;

package/dist/materials/graph.js

@@ -61,6 +61,13 @@ export const writeSchema = z
 })
     .strict()
     .refine((v) => v.materialId === undefined || v.cloneFrom === undefined, "Use materialId or cloneFrom, not both");
+export const programWriteSchema = z.object({
+    materialId: materialId.optional(),
+    cloneFrom: materialId.optional(),
+    layerIndex: z.number().int().min(0).max(7),
+    source: z.string().min(1).max(100_000),
+    objectIds: z.array(index).optional(),
+}).strict().refine(value => value.materialId === undefined || value.cloneFrom === undefined, "Use materialId or cloneFrom, not both");
 const nodeOptions = z
     .object({
     op: z.string().min(1),
@@ -272,7 +279,12 @@ export function validateMaterialGraph(input, catalog) {
             !inputPort ||
             graph.nodes[edge.input_node].op.startsWith("Output") ||
             !["Float", "Float3", "Color"].includes(output.type) ||
-            !["Float", "Float3", "Color"].includes(inputPort.type))
+            !(["Float", "Float3", "Color"].includes(inputPort.type) ||
+                (graph.nodes[edge.input_node].op === "OptionSelector" &&
+                    graph.nodes[edge.output_node].op === "Projection" &&
+                    edge.input_slot === 0 && edge.output_slot === 0 &&
+                    inputPort.type === "Enum" &&
+                    readVector(graph.nodes[edge.output_node], 5).x === 1)))
             throw new Error("Invalid connection: use existing numeric ports; output nodes are terminal and selectors are literals");
         const node = graph.nodes[edge.output_node];
         if (hidden(node.op, edge.output_slot) ||

package/dist/materials/lift.d.ts

@@ -0,0 +1,3 @@
+import type { MaterialGraph, MaterialNodeDescription } from "./types.js";
+/** Lift only graphs that compile back to equivalent native data. */
+export declare function liftMaterialFlowir(graph: MaterialGraph, catalog: Record<string, MaterialNodeDescription>): string;

package/dist/materials/lift.js

@@ -0,0 +1,216 @@
+import { comparableMaterialGraph, compileMaterialFlowir, materialDialectNames, materialFlowirRegistry, materialMathOperations, materialPortSlot, materialScalarMathOperations } from "./flowir.js";
+function number(node, slot) {
+    const value = node[`in${slot}`];
+    return value?.x ?? 0;
+}
+function literal(value, type) {
+    const v = value ?? { x: 0, y: 0, z: 0 };
+    if (type === "Vec3")
+        return `Vec3(${v.x},${v.y},${v.z})`;
+    if (type === "Bool")
+        return v.x === 0 ? "false" : "true";
+    return String(v.x);
+}
+function nodeType(node) {
+    if (node.op === "Math") {
+        const name = materialMathOperations[number(node, 0)];
+        if (!name)
+            throw new Error("Unsupported Math operation");
+        return name;
+    }
+    return node.op === "OptionSelector" ? "ProjectionModeSelector" : materialDialectNames[node.op] ?? node.op;
+}
+function safeId(value, fallback) {
+    if (typeof value !== "string" || value.length === 0)
+        return fallback;
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(value))
+        throw new Error(`Node/parameter name ${JSON.stringify(value)} cannot be preserved in FlowIR`);
+    return value;
+}
+/** Lift only graphs that compile back to equivalent native data. */
+export function liftMaterialFlowir(graph, catalog) {
+    const emitted = new Set();
+    const visiting = new Set();
+    const names = new Map();
+    const incoming = new Map();
+    for (const edge of graph.connections)
+        incoming.set(`${edge.output_node}:${edge.output_slot}`, { node: edge.input_node, slot: edge.input_slot });
+    const scalarMath = (index, seen = new Set()) => {
+        const node = graph.nodes[index];
+        if (node.op !== "Math" || number(node, 0) > 3 || seen.has(index))
+            return false;
+        const next = new Set(seen).add(index);
+        const users = graph.connections.filter(edge => edge.input_node === index);
+        return users.length > 0 && users.every(edge => catalog[graph.nodes[edge.output_node].op]?.inputs[edge.output_slot]?.type === "Float" ||
+            scalarMath(edge.output_node, next));
+    };
+    const types = graph.nodes.map((node, index) => scalarMath(index)
+        ? materialScalarMathOperations[number(node, 0)] : nodeType(node));
+    const lines = [];
+    const roles = new Map();
+    for (const [index, node] of graph.nodes.entries()) {
+        if (node.op === "Options")
+            continue;
+        const name = safeId(node.name, `n${index}`);
+        if ([...names.values()].includes(name))
+            throw new Error(`Duplicate FlowIR symbol ${name}`);
+        names.set(index, name);
+        roles.set(index, node.op === "Constant" || node.op === "Passthrough" ? `$${name}` : name);
+    }
+    const outputRef = (index, port) => {
+        const node = graph.nodes[index];
+        if (node.op === "Constant")
+            return names.get(index);
+        if (node.op === "Passthrough")
+            return names.get(index);
+        const type = types[index];
+        const schema = materialFlowirRegistry.getNode(type);
+        const output = schema?.outputs[port];
+        if (!output)
+            throw new Error(`Unsupported output ${node.op}.${port}`);
+        return `${names.get(index)}.${output.name}`;
+    };
+    for (const [index, node] of graph.nodes.entries()) {
+        if (node.op === "Passthrough") {
+            if (graph.connections.some(edge => edge.output_node === index))
+                throw new Error("Connected Passthrough inputs cannot be preserved");
+            lines.push(`const Vec3 ${names.get(index)} = ${literal(node.in0, "Vec3")}`);
+            emitted.add(index);
+            continue;
+        }
+        if (node.op !== "Constant")
+            continue;
+        if (number(node, 0) !== 0)
+            throw new Error("Constant operation selector cannot be preserved");
+        const exposure = number(node, 3);
+        if (![0, 1, 2, 3].includes(exposure))
+            throw new Error("Unsupported Constant panel widget");
+        const used = graph.connections.filter(edge => edge.input_node === index);
+        const ports = new Set(used.map(edge => edge.input_slot));
+        if (ports.has(0) || ports.size > 1)
+            throw new Error("Constant output usage cannot be preserved");
+        const color = exposure === 1 || exposure === 2 || ports.has(2);
+        if ((color && exposure !== 2 && ports.has(1)) || (!color && ports.has(2)))
+            throw new Error("Constant type does not match its connections");
+        const type = color ? "Vec3" : "Float";
+        const definition = literal(node[`in${color && exposure !== 2 ? 2 : 1}`], type);
+        const range = node.in4;
+        const suffix = exposure === 3 && range && range.y > range.x
+            ? ` min=${range.x} max=${range.y} step=${range.z}` : "";
+        lines.push(`${exposure === 0 ? "const" : "param"} ${type} ${names.get(index)} = ${definition}${suffix}`);
+        emitted.add(index);
+    }
+    const visit = (index) => {
+        if (emitted.has(index))
+            return;
+        if (visiting.has(index))
+            throw new Error("Material graph contains a cycle");
+        visiting.add(index);
+        const node = graph.nodes[index];
+        if (!node)
+            throw new Error("Material graph refers to a missing node");
+        for (const edge of graph.connections.filter(edge => edge.output_node === index))
+            visit(edge.input_node);
+        if (node.op === "Options") {
+            emitted.add(index);
+            return;
+        }
+        if (node.op === "Constant")
+            return;
+        const type = types[index];
+        const schema = materialFlowirRegistry.getNode(type);
+        if (!schema)
+            throw new Error(`Unsupported native material operation ${node.op}`);
+        const bindings = [];
+        for (const [portIndex, port] of schema.inputs.entries()) {
+            if (type === "ColorRamp" && /^Position[1-4]$|^Color[1-4]$/.test(port.name))
+                continue;
+            if (type === "ProjectionModeSelector")
+                continue;
+            if (type === "PredefinedTexture" && port.name === "Texture")
+                continue;
+            const nativeSlot = materialPortSlot(type, port.name, portIndex);
+            const edge = incoming.get(`${index}:${nativeSlot}`);
+            if (edge) {
+                bindings.push(`${port.name}=${outputRef(edge.node, edge.slot)}`);
+                continue;
+            }
+            const stored = node[`in${nativeSlot}`];
+            if (port.optional && stored === undefined)
+                continue;
+            if (node.op === "OutputMaterial")
+                continue;
+            if (materialFlowirRegistry.isEnum(port.type)) {
+                const value = materialFlowirRegistry.getEnumValues(port.type)[number(node, nativeSlot)];
+                if (!value)
+                    throw new Error(`Invalid ${type}.${port.name} enum`);
+                bindings.push(`${port.name}=${value}`);
+            }
+            else
+                bindings.push(`${port.name}=${literal(stored, port.type)}`);
+        }
+        if (type === "ColorRamp") {
+            const count = number(node, 1);
+            if (count < 2 || count > 4)
+                throw new Error("Unsupported ramp size");
+            const bytes = Uint8Array.from(node.external_data);
+            const view = new DataView(bytes.buffer);
+            for (let i = 0; i < count; i++) {
+                bindings.push(`Position${i + 1}=${view.getFloat32(i * 16, true)}`);
+                bindings.push(`Color${i + 1}=Vec3(${view.getFloat32(i * 16 + 4, true)},${view.getFloat32(i * 16 + 8, true)},${view.getFloat32(i * 16 + 12, true)})`);
+            }
+        }
+        if (type === "ProjectionModeSelector") {
+            const count = number(node, 0);
+            const selected = number(node, 1);
+            if (count < 2 || count > 4 || !Number.isInteger(selected) || selected < 0 || selected >= count)
+                throw new Error("Unsupported projection selector");
+            const bytes = Uint8Array.from(node.external_data);
+            const view = new DataView(bytes.buffer);
+            for (let i = 0; i < count; i++) {
+                const value = materialFlowirRegistry.getEnumValues("ProjectionMode")[view.getFloat32(i * 36, true)];
+                if (!value)
+                    throw new Error("Unsupported selector option");
+                bindings.push(`Option${i + 1}=${value}`);
+            }
+            if (selected !== 0)
+                bindings.push(`Selected=${selected + 1}`);
+        }
+        if (type === "PredefinedTexture") {
+            const bytes = Uint8Array.from(node.external_data);
+            const end = bytes.indexOf(0);
+            if (end < 1)
+                throw new Error("Texture path is missing");
+            bindings.push(`Texture=${JSON.stringify(new TextDecoder().decode(bytes.slice(0, end)))}`);
+        }
+        lines.push(`node ${names.get(index)} ${type}${bindings.length ? " " + bindings.join(" ") : ""}`);
+        emitted.add(index);
+        visiting.delete(index);
+    };
+    for (let index = 0; index < graph.nodes.length; index++)
+        visit(index);
+    const source = lines.join("\n");
+    const rebuilt = compileMaterialFlowir(source, catalog);
+    const remap = new Map();
+    const reordered = { nodes: [], connections: [] };
+    for (const [index, role] of roles) {
+        const target = rebuilt.symbols[role];
+        if (target === undefined)
+            throw new Error(`Cannot preserve ${role}`);
+        remap.set(index, target);
+        reordered.nodes[target] = graph.nodes[index];
+    }
+    if (reordered.nodes.length !== rebuilt.graph.nodes.length ||
+        reordered.nodes.filter(Boolean).length !== rebuilt.graph.nodes.length)
+        throw new Error("This graph requires extra nodes to represent in FlowIR");
+    reordered.connections = graph.connections.map(edge => ({ ...edge,
+        input_node: remap.get(edge.input_node), output_node: remap.get(edge.output_node),
+    }));
+    rebuilt.graph.nodes.forEach((node, index) => {
+        if (reordered.nodes[index].name === undefined)
+            delete node.name;
+    });
+    if (comparableMaterialGraph(rebuilt.graph) !== comparableMaterialGraph(reordered))
+        throw new Error("This native graph contains values or connections FlowIR cannot preserve");
+    return source;
+}