@womp/spark-agent 6.5.0 → 8.0.0

package/dist/geometry/common.d.ts

@@ -1,4 +1,5 @@
-import type { BackendPort, BackendRegistry, BackendValue } from "./backendRegistry.js";
+import type * as flowir from "@womp/flowir";
+import type { BackendPort, BackendRegistry, BackendValue, GraphExt } from "./backendRegistry.js";
 /** Scalar backend storage is zero-initialized. Empty arrays have node-specific semantics. */
 export declare function defaultScalar(port: BackendPort): BackendValue | null;
 export type Edge = {
@@ -14,11 +15,13 @@ export type Edge = {
 export declare const VALUE_BACKEND_NAMES: Record<string, string>;
 /** FlowIR scalar type → backend node name (inverse of VALUE_BACKEND_NAMES). */
 export declare function valueBackendName(typeName: string): string | undefined;
-export declare function titleToAstName(title: string): string;
 export declare function astNameToTitle(s: string): string;
+export declare function storedSymbol(graphExt: GraphExt, bid: string): string | undefined;
+export declare function paramName(graphExt: GraphExt, valueBid: string, inputBid: string): string | undefined;
 export declare function isArrayPortType(type: string): boolean;
 export declare function parseConnection(key: string): Edge | null;
 export declare function buildIncomingMap(connections: Record<string, 0>): Map<string, Edge[]>;
+export declare function backendTypeId(flowirRegistry: flowir.Registry, name: string): number;
 /** Resolve the GIP and value-node type IDs from the backend registry. */
 export declare function resolveParamTypeIds(backendRegistry: BackendRegistry): {
     gipTypeId: number | null;

package/dist/geometry/common.js

@@ -4,7 +4,7 @@ export function defaultScalar(port) {
         return 0;
     if (port.type === "Bool")
         return false;
-    if (port.type === "Vec" || port.type === "Vec3")
+    if (port.type === "Vec")
         return { x: 0, y: 0, z: 0 };
     return null;
 }
@@ -25,7 +25,7 @@ export function valueBackendName(typeName) {
     }
     return undefined;
 }
-export function titleToAstName(title) {
+function titleToAstName(title) {
     return title
         .trim()
         .replace(/\s+(.)/g, (_, c) => "_" + c.toLowerCase())
@@ -36,8 +36,15 @@ export function astNameToTitle(s) {
         .replace(/_./g, (m) => " " + m[1].toUpperCase())
         .replace(/^./, (m) => m.toUpperCase());
 }
+export function storedSymbol(graphExt, bid) {
+    return graphExt.nodes?.[bid]?.flowirSymbol;
+}
+export function paramName(graphExt, valueBid, inputBid) {
+    const label = graphExt.nodes?.[inputBid]?.name;
+    return storedSymbol(graphExt, valueBid) ?? (label ? titleToAstName(label) : undefined);
+}
 export function isArrayPortType(type) {
-    return type.endsWith("[]") || type.endsWith("Array");
+    return type.endsWith("Array");
 }
 export function parseConnection(key) {
     const m = key.match(/^(\d+):(\d+)-(\d+):(\d+)$/);
@@ -65,6 +72,14 @@ export function buildIncomingMap(connections) {
     }
     return incoming;
 }
+export function backendTypeId(flowirRegistry, name) {
+    const node = flowirRegistry.getNode(name);
+    if (!node)
+        throw new Error(`Unknown dialect node ${name}.`);
+    if (!/^\d+$/.test(node.type))
+        throw new Error(`Dialect node ${name} has type ${JSON.stringify(node.type)}; the geometry backend needs a decimal type id.`);
+    return Number(node.type);
+}
 /** Resolve the GIP and value-node type IDs from the backend registry. */
 export function resolveParamTypeIds(backendRegistry) {
     const gipTypeId = backendRegistry.getSchemaByName("GroupInputParam")?.typeId ?? null;

package/dist/geometry/compiler.js

@@ -16,9 +16,9 @@ export function compileGeometry(source) {
     // of the text, not by whoever forwards it.
     if (!parsed.ok)
         throw new Error(formatBoundedDiagnostics(source, parsed.diagnostics));
-    const result = flowir.compileFromProgram(parsed.program, source, flowirRegistry);
+    const result = flowir.compileFromProgram(parsed.program, flowirRegistry);
     if (!result.ok)
-        throw new Error(formatBoundedDiagnostics(result.source, result.diagnostics));
+        throw new Error(formatBoundedDiagnostics(source, result.diagnostics));
     const compiled = lower(parsed.program, flowirRegistry, backendRegistry);
     for (const statement of parsed.program.statements) {
         const name = statement.kind === "node"

package/dist/geometry/diagnostics.d.ts

@@ -1,11 +1,7 @@
-import type { Diagnostic } from "@womp/flowir";
+import * as flowir from "@womp/flowir";
 export declare const MAX_REPORTED_DIAGNOSTICS = 5;
 export declare const MAX_DIAGNOSTIC_BYTES: number;
-type DiagnosticLike = Pick<Diagnostic, "code" | "message" | "line" | "column" | "hint">;
-export declare function formatBoundedDiagnostics(source: string, diagnostics: readonly DiagnosticLike[], limits?: {
-    count?: number;
-    bytes?: number;
-}): string;
+export declare function formatBoundedDiagnostics(source: string, diagnostics: readonly flowir.Diagnostic[]): string;
 /**
  * A host-assembled diagnostic list, bounded the same way: each entry to
  * `MAX_DIAGNOSTIC_BYTES`, the list to `MAX_REPORTED_DIAGNOSTICS` entries, with
@@ -15,4 +11,3 @@ export declare function boundedDiagnostics(diagnostics: readonly string[], limit
     count?: number;
     bytes?: number;
 }): string[];
-export {};

package/dist/geometry/diagnostics.js

@@ -1,57 +1,9 @@
+import * as flowir from "@womp/flowir";
 import { boundedText } from "../bounded-output.js";
-// WHY THIS FILE EXISTS. `@womp/flowir`'s own `formatDiagnostics` emits one
-// four-line block per diagnostic -- header, source line, caret, hint -- and
-// joins them, so a compiler that reports the same one-character mistake five
-// times repeats the offending source line five times and its hint five times.
-// That string is what `compileGeometry` throws and what a rejected
-// `geometry.write` hands the model as a diagnostic; on staging one bad enum
-// value cost a whole turn. The compiler holds the structured diagnostics
-// already, so the bound belongs here rather than behind a package this one
-// only consumes.
-//
-// What is kept: every diagnostic's header (code, line, column, message), the
-// source line once per distinct line, its caret, and each distinct hint once.
-// What is dropped is only repetition and the tail past the limits, and the
-// message says so.
 export const MAX_REPORTED_DIAGNOSTICS = 5;
 export const MAX_DIAGNOSTIC_BYTES = 4 * 1024;
-export function formatBoundedDiagnostics(source, diagnostics, limits = {}) {
-    const count = limits.count ?? MAX_REPORTED_DIAGNOSTICS;
-    const bytes = limits.bytes ?? MAX_DIAGNOSTIC_BYTES;
-    if (diagnostics.length === 0)
-        return "";
-    const lines = source.replace(/\r\n?/gu, "\n").split("\n");
-    const gutterWidth = String(lines.length || 1).length;
-    const pointerPrefix = `${" ".repeat(gutterWidth)} | `;
-    const shownLines = new Set();
-    const shownCarets = new Set();
-    const shownHints = new Set();
-    const out = [];
-    for (const diagnostic of diagnostics.slice(0, count)) {
-        out.push(`error[${diagnostic.code}] L${diagnostic.line}:${diagnostic.column} ${diagnostic.message}`);
-        const sourceLine = lines[diagnostic.line - 1];
-        if (sourceLine !== undefined) {
-            // A line already quoted is not quoted again -- that repetition is the
-            // defect this bounds. Its caret still is, once per column, so every
-            // diagnostic keeps a marker against the quoted line above it.
-            if (shownLines.has(diagnostic.line) === false) {
-                shownLines.add(diagnostic.line);
-                out.push(`${String(diagnostic.line).padStart(gutterWidth, " ")} | ${sourceLine}`);
-            }
-            const caret = `${pointerPrefix}${" ".repeat(Math.max(diagnostic.column - 1, 0))}^`;
-            if (shownCarets.has(`${diagnostic.line}:${caret}`) === false) {
-                shownCarets.add(`${diagnostic.line}:${caret}`);
-                out.push(caret);
-            }
-        }
-        if (shownHints.has(diagnostic.hint) === false) {
-            shownHints.add(diagnostic.hint);
-            out.push(`${pointerPrefix}hint: ${diagnostic.hint}`);
-        }
-    }
-    if (diagnostics.length > count)
-        out.push(`${diagnostics.length - count} more diagnostics were omitted (${count} of ${diagnostics.length} shown). Fix these, then compile again.`);
-    return boundedText(out.join("\n"), bytes, "Diagnostics");
+export function formatBoundedDiagnostics(source, diagnostics) {
+    return boundedText(flowir.formatDiagnostics(source, diagnostics, MAX_REPORTED_DIAGNOSTICS), MAX_DIAGNOSTIC_BYTES, "Diagnostics");
 }
 /**
  * A host-assembled diagnostic list, bounded the same way: each entry to

package/dist/geometry/graph.d.ts

@@ -31,9 +31,9 @@ export declare const graphExtSchema: z.ZodObject<{
     nodes: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
         name: z.ZodOptional<z.ZodString>;
         position: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+        flowirSymbol: z.ZodOptional<z.ZodString>;
     }, z.core.$catchall<z.ZodJSONSchema>>>>;
 }, z.core.$catchall<z.ZodJSONSchema>>;
 export type GeometryGraph = z.infer<typeof geometryGraphSchema>;
 export type GraphData = z.infer<typeof graphDataSchema>;
-/** FlowIR statement roles map to backend IDs only for the current conversion. */
 export type StatementNodes = Record<string, string>;

package/dist/geometry/graph.js

@@ -25,6 +25,7 @@ export const graphExtSchema = z
         .object({
         name: z.string().optional(),
         position: z.array(z.number()).length(2).optional(),
+        flowirSymbol: z.string().optional(),
     })
         .catchall(z.json()))
         .default({}),

package/dist/geometry/index.d.ts

@@ -5,5 +5,4 @@ export { lower } from "./lower.js";
 export type { LowerResult } from "./lower.js";
 export { lift } from "./lift.js";
 export { writeParamData } from "./writeParamData.js";
-export declare function loadGeoNodesDialect(): flowir.DialectSchema;
 export declare function createGeoNodesRegistry(): flowir.Registry;

package/dist/geometry/index.js

@@ -4,9 +4,6 @@ export { BackendRegistry } from "./backendRegistry.js";
 export { lower } from "./lower.js";
 export { lift } from "./lift.js";
 export { writeParamData } from "./writeParamData.js";
-export function loadGeoNodesDialect() {
-    return dialectJson;
-}
 export function createGeoNodesRegistry() {
     return flowir.Registry.fromJsonObject(dialectJson);
 }

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;