@womp/spark-agent 7.0.0 → 8.0.0

package/dist/geometry/lift.js

@@ -1,11 +1,42 @@
-import { VALUE_BACKEND_NAMES, titleToAstName, isArrayPortType, buildIncomingMap, defaultScalar, } from "./common.js";
-const POS = { line: 0, column: 0 };
-function decimal(value) {
-    const text = value.toLocaleString("en-US", {
-        useGrouping: false,
-        maximumSignificantDigits: 21,
+import { VALUE_BACKEND_NAMES, backendTypeId, isArrayPortType, paramName, storedSymbol, buildIncomingMap, defaultScalar, } from "./common.js";
+const NO_SOURCE_POSITION = { line: 0, column: 0 };
+function uniqueSymbol(prefix, start, taken) {
+    let index = start;
+    while (taken.has(`${prefix}${index}`))
+        index += 1;
+    taken.add(`${prefix}${index}`);
+    return `${prefix}${index}`;
+}
+function resolveNames(valueNodes, paramInputBid, dialectBids, graphExt) {
+    const names = new Map();
+    const taken = new Set();
+    const keep = (bid, name) => {
+        if (name === undefined)
+            return;
+        names.set(bid, name);
+        taken.add(name);
+    };
+    for (const vNode of valueNodes) {
+        const inputBid = paramInputBid(vNode);
+        keep(vNode.bid, inputBid
+            ? paramName(graphExt, vNode.bid, inputBid)
+            : storedSymbol(graphExt, vNode.bid));
+    }
+    for (const bid of dialectBids)
+        keep(bid, storedSymbol(graphExt, bid));
+    let paramIndex = 0;
+    let constIndex = 0;
+    for (const vNode of valueNodes) {
+        const isParam = paramInputBid(vNode) !== undefined;
+        const index = isParam ? paramIndex++ : constIndex++;
+        if (!names.has(vNode.bid))
+            names.set(vNode.bid, uniqueSymbol(isParam ? "p" : "c", index, taken));
+    }
+    dialectBids.forEach((bid, index) => {
+        if (!names.has(bid))
+            names.set(bid, uniqueSymbol("n", index, taken));
     });
-    return text.includes(".") ? text : `${text}.0`;
+    return names;
 }
 function isVec3Object(v) {
     if (!v || typeof v !== "object")
@@ -105,70 +136,47 @@ function decodeScalarValue(raw, typeName) {
         return {
             kind: "vec3",
             value: [vec.x, vec.y, vec.z],
-            raw: `Vec3(${decimal(vec.x)}, ${decimal(vec.y)}, ${decimal(vec.z)})`,
-            pos: POS,
+            ...NO_SOURCE_POSITION,
         };
     }
-    if (typeName === "Bool" && typeof raw === "boolean") {
-        return { kind: "bool", value: raw, pos: POS };
-    }
     if (typeName === "Int" && typeof raw === "number") {
         const v = Math.trunc(raw);
-        return { kind: "int", value: v, raw: String(v), pos: POS };
+        return { kind: "int", value: v, ...NO_SOURCE_POSITION };
     }
     const num = typeof raw === "number" ? raw : 0;
-    return { kind: "float", value: num, raw: decimal(num), pos: POS };
+    return { kind: "float", value: num, ...NO_SOURCE_POSITION };
 }
 function decodeBackendValue(raw, backendPort, dialectPort, flowirRegistry) {
-    if (dialectPort.enum && typeof raw === "number") {
-        const values = flowirRegistry.getEnumValues(dialectPort.enum);
-        const name = values[raw];
-        if (name)
-            return { kind: "ident", name, pos: POS };
-    }
-    if (backendPort.enumValues?.length && typeof raw === "number") {
-        const name = backendPort.enumValues[raw];
-        if (name)
-            return { kind: "ident", name, pos: POS };
+    if (flowirRegistry.isEnum(dialectPort.type)) {
+        const name = typeof raw === "number"
+            ? flowirRegistry.getEnumValues(dialectPort.type)[raw]
+            : undefined;
+        return name ? { kind: "ident", name, ...NO_SOURCE_POSITION } : null;
     }
     const unwrapped = isArrayPortType(backendPort.type) && Array.isArray(raw) && raw.length === 1
         ? raw[0]
         : raw;
-    if (isVec3Object(unwrapped)) {
-        return {
-            kind: "vec3",
-            value: [unwrapped.x, unwrapped.y, unwrapped.z],
-            raw: `Vec3(${decimal(unwrapped.x)}, ${decimal(unwrapped.y)}, ${decimal(unwrapped.z)})`,
-            pos: POS,
-        };
-    }
+    if (isVec3Object(unwrapped))
+        return decodeScalarValue(unwrapped, "Vec3");
     if (typeof unwrapped === "boolean") {
-        return { kind: "bool", value: unwrapped, pos: POS };
+        return { kind: "bool", value: unwrapped, ...NO_SOURCE_POSITION };
     }
     if (typeof unwrapped === "number") {
         if (dialectPort.type === "Int" || dialectPort.type === "Int[]") {
             const v = Math.trunc(unwrapped);
-            return { kind: "int", value: v, raw: String(v), pos: POS };
+            return { kind: "int", value: v, ...NO_SOURCE_POSITION };
         }
-        return {
-            kind: "float",
-            value: unwrapped,
-            raw: decimal(unwrapped),
-            pos: POS,
-        };
+        return { kind: "float", value: unwrapped, ...NO_SOURCE_POSITION };
     }
     return null;
 }
-function liftParam(vNode, gipBid, paramCounter, ctx) {
+function liftParam(vNode, gipBid, name, ctx) {
     const typeName = vNode.valueTypeName ?? "Float";
-    const extName = ctx.graphExt.nodes?.[gipBid]?.name;
-    const name = extName ? titleToAstName(extName) : `p${paramCounter}`;
     const rawDefault = getData(ctx.graph, vNode.bid, "0");
-    const paramTypeName = typeName === "Bool" ? "Float" : typeName;
     return {
         kind: "param",
         name,
-        typeName: paramTypeName,
+        typeName,
         value: rawDefault != null
             ? decodeScalarValue(rawDefault, typeName)
             : decodeScalarValue(typeName === "Vec3" ? { x: 0, y: 0, z: 0 } : 0, typeName),
@@ -177,53 +185,50 @@ function liftParam(vNode, gipBid, paramCounter, ctx) {
             max: getDataAsNumber(ctx.graph, gipBid, "1"),
             step: getDataAsNumber(ctx.graph, gipBid, "2"),
         },
-        pos: POS,
+        ...NO_SOURCE_POSITION,
     };
 }
-function liftConst(vNode, constCounter, ctx) {
+function liftConst(vNode, name, ctx) {
     const typeName = vNode.valueTypeName ?? "Float";
     const rawDefault = getData(ctx.graph, vNode.bid, "0");
     return {
         kind: "const",
-        name: `c${constCounter}`,
-        typeName: typeName,
+        name,
+        typeName,
         value: rawDefault != null
             ? decodeScalarValue(rawDefault, typeName)
             : decodeScalarValue(typeName === "Vec3" ? { x: 0, y: 0, z: 0 } : 0, typeName),
-        pos: POS,
+        ...NO_SOURCE_POSITION,
     };
 }
 function resolveInputBinding(bid, idx, dialectPort, backendPort, ctx) {
     const connEdge = ctx.incoming.get(bid)?.find((e) => e.toPort === idx);
     if (connEdge) {
         const sourceNode = ctx.classMap.get(connEdge.fromBid);
-        if (!sourceNode)
+        const sourceName = ctx.names.get(connEdge.fromBid);
+        if (!sourceNode || !sourceName)
             return null;
-        const paramName = ctx.paramBids.get(connEdge.fromBid);
-        if (paramName) {
+        if (sourceNode.cls === "value") {
             return {
                 name: dialectPort.name,
-                value: { kind: "ident", name: paramName, pos: POS },
-                pos: POS,
+                value: { kind: "ident", name: sourceName, ...NO_SOURCE_POSITION },
+                ...NO_SOURCE_POSITION,
             };
         }
         if (sourceNode.cls === "dialect" && sourceNode.dialectName) {
             const sourceDialect = ctx.flowirRegistry.getNode(sourceNode.dialectName);
-            const sourceStmtId = ctx.dialectStmtIds.get(connEdge.fromBid);
-            if (sourceDialect && sourceStmtId) {
-                const outputPort = sourceDialect.outputs[connEdge.fromPort];
-                if (outputPort) {
-                    return {
-                        name: dialectPort.name,
-                        value: {
-                            kind: "ref",
-                            nodeId: sourceStmtId,
-                            port: outputPort.name,
-                            pos: POS,
-                        },
-                        pos: POS,
-                    };
-                }
+            const outputPort = sourceDialect?.outputs[connEdge.fromPort];
+            if (outputPort) {
+                return {
+                    name: dialectPort.name,
+                    value: {
+                        kind: "ref",
+                        nodeId: sourceName,
+                        port: outputPort.name,
+                        ...NO_SOURCE_POSITION,
+                    },
+                    ...NO_SOURCE_POSITION,
+                };
             }
         }
         return null;
@@ -234,11 +239,11 @@ function resolveInputBinding(bid, idx, dialectPort, backendPort, ctx) {
     const decoded = decodeBackendValue(rawData, backendPort, dialectPort, ctx.flowirRegistry);
     if (!decoded)
         return null;
-    return { name: dialectPort.name, value: decoded, pos: POS };
+    return { name: dialectPort.name, value: decoded, ...NO_SOURCE_POSITION };
 }
 function liftNodeStmt(bid, cNode, ctx) {
     const dialectName = cNode.dialectName;
-    const stmtId = ctx.dialectStmtIds.get(bid);
+    const stmtId = ctx.names.get(bid);
     const dialectNode = ctx.flowirRegistry.getNode(dialectName);
     if (!dialectNode)
         return null;
@@ -254,7 +259,13 @@ function liftNodeStmt(bid, cNode, ctx) {
         if (binding)
             inputs.push(binding);
     }
-    return { kind: "node", id: stmtId, nodeType: dialectName, inputs, pos: POS };
+    return {
+        kind: "node",
+        id: stmtId,
+        nodeType: dialectName,
+        inputs,
+        ...NO_SOURCE_POSITION,
+    };
 }
 function liftOutStmt(oNode, ctx) {
     const geoEdge = ctx.incoming.get(oNode.bid)?.find((e) => e.toPort === 1);
@@ -264,7 +275,7 @@ function liftOutStmt(oNode, ctx) {
     if (!sourceNode || sourceNode.cls !== "dialect" || !sourceNode.dialectName)
         return null;
     const sourceDialect = ctx.flowirRegistry.getNode(sourceNode.dialectName);
-    const sourceStmtId = ctx.dialectStmtIds.get(geoEdge.fromBid);
+    const sourceStmtId = ctx.names.get(geoEdge.fromBid);
     if (!sourceDialect || !sourceStmtId)
         return null;
     const outputPort = sourceDialect.outputs[geoEdge.fromPort];
@@ -277,20 +288,16 @@ function liftOutStmt(oNode, ctx) {
             kind: "ref",
             nodeId: sourceStmtId,
             port: outputPort.name,
-            pos: POS,
+            ...NO_SOURCE_POSITION,
         },
-        pos: POS,
+        ...NO_SOURCE_POSITION,
     };
 }
 export function lift(graph, graphExt, flowirRegistry, backendRegistry) {
     const reverseMap = new Map();
     for (const name of flowirRegistry.listNodeNames()) {
-        const id = flowirRegistry.getNodeTypeId(name);
-        if (id == null)
-            continue;
+        const id = backendTypeId(flowirRegistry, name);
         const outputs = backendRegistry.getSchema(id)?.outputs;
-        // Dialect aliases can share a backend ID. Lift the native output type,
-        // so vector math is not accidentally narrowed to its scalar alias.
         const matches = flowirRegistry
             .getNode(name)
             ?.outputs.every((port, index) => port.type ===
@@ -313,52 +320,37 @@ export function lift(graph, graphExt, flowirRegistry, backendRegistry) {
     const classMap = new Map();
     for (const node of classified)
         classMap.set(node.bid, node);
+    const valueNodes = classified.filter((n) => n.cls === "value");
+    const paramInputBid = (vNode) => incoming
+        .get(vNode.bid)
+        ?.find((e) => classMap.get(e.fromBid)?.cls === "gip" && e.toPort === 0)
+        ?.fromBid;
+    const dialectBids = toposort(classified.filter((n) => n.cls === "dialect").map((n) => n.bid), incoming);
     const ctx = {
         graph,
-        graphExt,
         flowirRegistry,
         backendRegistry,
         incoming,
         classMap,
-        paramBids: new Map(),
-        dialectStmtIds: new Map(),
+        names: resolveNames(valueNodes, paramInputBid, dialectBids, graphExt),
     };
     const statements = [];
     const nodeIds = {};
-    let paramCounter = 0;
-    let constCounter = 0;
-    const valueNodes = classified.filter((n) => n.cls === "value");
     for (const vNode of valueNodes) {
-        const edges = incoming.get(vNode.bid);
-        const gipEdge = edges?.find((e) => classMap.get(e.fromBid)?.cls === "gip" && e.toPort === 0);
-        if (gipEdge) {
-            statements.push(liftParam(vNode, gipEdge.fromBid, paramCounter, ctx));
-            const stmt = statements[statements.length - 1];
-            ctx.paramBids.set(vNode.bid, stmt.name);
-            nodeIds[`param:${stmt.name}`] = vNode.bid;
-            nodeIds[`param-input:${stmt.name}`] = gipEdge.fromBid;
-            paramCounter++;
+        const name = ctx.names.get(vNode.bid);
+        const inputBid = paramInputBid(vNode);
+        if (inputBid) {
+            statements.push(liftParam(vNode, inputBid, name, ctx));
+            nodeIds[`param:${name}`] = vNode.bid;
+            nodeIds[`param-input:${name}`] = inputBid;
         }
         else {
-            statements.push(liftConst(vNode, constCounter, ctx));
-            const stmt = statements[statements.length - 1];
-            ctx.paramBids.set(vNode.bid, stmt.name);
-            nodeIds[`const:${stmt.name}`] = vNode.bid;
-            constCounter++;
+            statements.push(liftConst(vNode, name, ctx));
+            nodeIds[`const:${name}`] = vNode.bid;
         }
     }
-    const dialectBids = classified
-        .filter((n) => n.cls === "dialect")
-        .map((n) => n.bid);
-    const sortedBids = toposort(dialectBids, incoming);
-    let nodeCounter = 0;
-    for (const bid of sortedBids) {
-        ctx.dialectStmtIds.set(bid, `n${nodeCounter}`);
-        nodeCounter++;
-    }
-    for (const bid of sortedBids) {
-        const cNode = classMap.get(bid);
-        const stmt = liftNodeStmt(bid, cNode, ctx);
+    for (const bid of dialectBids) {
+        const stmt = liftNodeStmt(bid, classMap.get(bid), ctx);
         if (stmt) {
             statements.push(stmt);
             nodeIds[`node:${stmt.id}`] = bid;

package/dist/geometry/lower.js

@@ -1,4 +1,4 @@
-import { astNameToTitle, defaultScalar, valueBackendName, isArrayPortType, } from "./common.js";
+import { astNameToTitle, backendTypeId, defaultScalar, valueBackendName, isArrayPortType, } from "./common.js";
 class GraphBuilder {
     nextId = 0;
     nodes = {};
@@ -28,10 +28,7 @@ class GraphBuilder {
     }
 }
 function resolveBackendSchema(nodeType, flowirRegistry, backendRegistry) {
-    const typeId = flowirRegistry.getNodeTypeId(nodeType);
-    if (typeId === null)
-        return null;
-    return backendRegistry.getSchema(typeId);
+    return backendRegistry.getSchema(backendTypeId(flowirRegistry, nodeType));
 }
 function toLiteral(value) {
     if (value.kind === "int")
@@ -45,10 +42,7 @@ function toLiteral(value) {
     return null;
 }
 function isVecPortType(type) {
-    return (type === "Vec3" ||
-        type === "Vec" ||
-        type === "Vec3[]" ||
-        type === "VecArray");
+    return type === "Vec" || type === "VecArray";
 }
 function isZeroVec(v) {
     if (!v || typeof v !== "object")
@@ -56,11 +50,9 @@ function isZeroVec(v) {
     const vec = v;
     return vec.x === 0 && vec.y === 0 && vec.z === 0;
 }
-function isDefaultValue(value, port, dialectPort) {
+function isDefaultValue(value, port) {
     if (port.enumValues?.length)
         return false;
-    if (dialectPort?.enum)
-        return false;
     if (defaultScalar(port) === null)
         return false;
     if (value === 0)
@@ -91,9 +83,9 @@ function encodeLiteralForPort(literal, port) {
     }
     return isArray ? [scalar] : scalar;
 }
-function trySetInput(bid, portIndex, literal, port, dialectPort, graph) {
+function trySetInput(bid, portIndex, literal, port, graph) {
     const encoded = encodeLiteralForPort(literal, port);
-    if (!isDefaultValue(encoded, port, dialectPort)) {
+    if (!isDefaultValue(encoded, port)) {
         graph.setInput(bid, portIndex, encoded);
     }
 }
@@ -101,27 +93,19 @@ function encodeValue(value, port, dialectPort, flowirRegistry) {
     const literal = toLiteral(value);
     if (literal)
         return encodeLiteralForPort(literal, port);
-    if (value.kind === "ident") {
-        if (dialectPort?.enum) {
-            const idx = flowirRegistry
-                .getEnumValues(dialectPort.enum)
-                .indexOf(value.name);
-            if (idx >= 0)
-                return idx;
-        }
-        if (port.enumValues?.length) {
-            const idx = port.enumValues.indexOf(value.name);
-            if (idx >= 0)
-                return idx;
-        }
-    }
-    return null;
+    if (value.kind !== "ident" || !flowirRegistry.isEnum(dialectPort.type))
+        return null;
+    const index = flowirRegistry
+        .getEnumValues(dialectPort.type)
+        .indexOf(value.name);
+    return index >= 0 ? index : null;
 }
 function valueNodeSchema(typeName, backendRegistry) {
     const backendName = valueBackendName(typeName);
-    if (!backendName)
-        return null;
-    return backendRegistry.getSchemaByName(backendName);
+    const schema = backendName ? backendRegistry.getSchemaByName(backendName) : null;
+    if (!schema)
+        throw new Error(`Geometry has no value node for ${typeName}.`);
+    return schema;
 }
 function lowerFloatExpr(expr, ctx) {
     if (expr.kind === "float_lit")
@@ -157,7 +141,7 @@ function lowerFloatExpr(expr, ctx) {
     if (left.kind === "literal") {
         const port = mathFloat.inputs[1];
         if (port)
-            trySetInput(bid, 1, { kind: "float", value: left.value }, port, null, ctx.graph);
+            trySetInput(bid, 1, { kind: "float", value: left.value }, port, ctx.graph);
     }
     else {
         ctx.graph.connect(left.backendNodeId, left.portIndex, bid, 1);
@@ -165,7 +149,7 @@ function lowerFloatExpr(expr, ctx) {
     if (right.kind === "literal") {
         const port = mathFloat.inputs[2];
         if (port)
-            trySetInput(bid, 2, { kind: "float", value: right.value }, port, null, ctx.graph);
+            trySetInput(bid, 2, { kind: "float", value: right.value }, port, ctx.graph);
     }
     else {
         ctx.graph.connect(right.backendNodeId, right.portIndex, bid, 2);
@@ -187,7 +171,7 @@ function lowerVec3Ctor(ctor, targetBid, targetPortIndex, targetPort, ctx) {
         if (result.kind === "literal") {
             const port = combineXyz.inputs[idx];
             if (port)
-                trySetInput(combineBid, idx, { kind: "float", value: result.value }, port, null, ctx.graph);
+                trySetInput(combineBid, idx, { kind: "float", value: result.value }, port, ctx.graph);
         }
         else {
             ctx.graph.connect(result.backendNodeId, result.portIndex, combineBid, idx);
@@ -198,22 +182,19 @@ function lowerVec3Ctor(ctor, targetBid, targetPortIndex, targetPort, ctx) {
 }
 function lowerConst(stmt, ctx) {
     const schema = valueNodeSchema(stmt.typeName, ctx.backendRegistry);
-    if (!schema)
-        return;
     const lit = toLiteral(stmt.value);
     if (!lit)
         return;
     const bid = ctx.graph.addNode(schema.typeId);
     const backendPort = schema.inputs[0];
     if (backendPort)
-        trySetInput(bid, 0, lit, backendPort, null, ctx.graph);
+        trySetInput(bid, 0, lit, backendPort, ctx.graph);
     ctx.paramNodes.set(stmt.name, bid);
     ctx.nodeIds[`const:${stmt.name}`] = bid;
+    ctx.graphExt.nodes[bid] = { flowirSymbol: stmt.name };
 }
 function lowerParam(stmt, ctx) {
     const schema = valueNodeSchema(stmt.typeName, ctx.backendRegistry);
-    if (!schema)
-        return;
     const lit = toLiteral(stmt.value);
     if (!lit)
         return;
@@ -222,17 +203,18 @@ function lowerParam(stmt, ctx) {
         return;
     const gipBid = ctx.graph.addNode(gipSchema.typeId);
     ctx.nodeIds[`param-input:${stmt.name}`] = gipBid;
-    ctx.nodeNames.set(gipBid, astNameToTitle(stmt.name));
+    ctx.graphExt.nodes[gipBid] = { name: astNameToTitle(stmt.name) };
     ctx.graph.setInput(gipBid, 0, stmt.range.min);
     ctx.graph.setInput(gipBid, 1, stmt.range.max);
     ctx.graph.setInput(gipBid, 2, stmt.range.step);
     const bid = ctx.graph.addNode(schema.typeId);
     const backendPort = schema.inputs[0];
     if (backendPort)
-        trySetInput(bid, 0, lit, backendPort, null, ctx.graph);
+        trySetInput(bid, 0, lit, backendPort, ctx.graph);
     ctx.graph.connect(gipBid, 0, bid, 0);
     ctx.paramNodes.set(stmt.name, bid);
     ctx.nodeIds[`param:${stmt.name}`] = bid;
+    ctx.graphExt.nodes[bid] = { flowirSymbol: stmt.name };
 }
 function lowerNodeStmt(stmt, ctx, pending) {
     const schema = resolveBackendSchema(stmt.nodeType, ctx.flowirRegistry, ctx.backendRegistry);
@@ -241,6 +223,7 @@ function lowerNodeStmt(stmt, ctx, pending) {
     const bid = ctx.graph.addNode(schema.typeId);
     ctx.backendIds.set(stmt.id, bid);
     ctx.nodeIds[`node:${stmt.id}`] = bid;
+    ctx.graphExt.nodes[bid] = { flowirSymbol: stmt.id };
     ctx.nodeTypes.set(stmt.id, stmt.nodeType);
     ctx.nodeSchemas.set(stmt.id, schema);
     for (const input of stmt.inputs) {
@@ -272,7 +255,7 @@ function lowerNodeStmt(stmt, ctx, pending) {
         if (input.value.kind === "vec3ctor") {
             const lowered = lowerVec3Ctor(input.value, bid, resolved.index, backendPort, ctx);
             if (lowered !== null &&
-                !isDefaultValue(lowered, backendPort, resolved.port)) {
+                !isDefaultValue(lowered, backendPort)) {
                 ctx.graph.setInput(bid, resolved.index, lowered);
             }
             continue;
@@ -280,7 +263,7 @@ function lowerNodeStmt(stmt, ctx, pending) {
         const encoded = encodeValue(input.value, backendPort, resolved.port, ctx.flowirRegistry);
         if (encoded === null)
             continue;
-        if (isDefaultValue(encoded, backendPort, resolved.port))
+        if (isDefaultValue(encoded, backendPort))
             continue;
         ctx.graph.setInput(bid, resolved.index, encoded);
     }
@@ -337,7 +320,7 @@ export function lower(program, flowirRegistry, backendRegistry) {
         backendIds: new Map(),
         nodeTypes: new Map(),
         nodeSchemas: new Map(),
-        nodeNames: new Map(),
+        graphExt: { nodes: {} },
         nodeIds: {},
     };
     const pending = [];
@@ -358,8 +341,5 @@ export function lower(program, flowirRegistry, backendRegistry) {
         }
     }
     resolvePendingConnections(pending, ctx);
-    const graphExt = {
-        nodes: Object.fromEntries([...ctx.nodeNames.entries()].map(([bid, name]) => [bid, { name }])),
-    };
-    return { graph: graph.toPayload(), graphExt, nodeIds: ctx.nodeIds };
+    return { graph: graph.toPayload(), graphExt: ctx.graphExt, nodeIds: ctx.nodeIds };
 }