@shaderfrog/core 2.0.1 → 3.0.1

package/engine.d.ts

@@ -1,10 +1,10 @@
 import { Program } from '@shaderfrog/glsl-parser/ast';
 import { MergeOptions } from './graph/shader-sections';
 import { Graph, ShaderStage } from './graph/graph-types';
-import { NodePosition } from './graph/base-node';
+import { NodeInput, NodePosition } from './graph/base-node';
 import { DataNode, UniformDataType } from './graph/data-nodes';
 import { CodeNode, NodeProperty, SourceNode } from './graph/code-nodes';
-import { NodeContext } from './graph/context';
+import { NodeContext, NodeContexts } from './graph/context';
 import { NodeParser } from './graph/parsers';
 export declare enum EngineNodeType {
     toon = "toon",
@@ -30,9 +30,44 @@ export interface Engine {
         [EngineNodeType.toon]?: ToonNodeConstructor;
     };
 }
-export type EngineContext = {
+export type EngineContext<T = any> = {
     engine: string;
     nodes: Record<string, NodeContext>;
+    runtime: T;
+    debuggingNonsense: {
+        vertexSource?: string;
+        vertexPreprocessed?: string;
+        fragmentPreprocessed?: string;
+        fragmentSource?: string;
+    };
+};
+export declare const extendNodeContext: (context: EngineContext, nodeId: string, nodeContext: Partial<NodeContext>) => {
+    nodes: {
+        [x: string]: NodeContext | {
+            id?: string;
+            name?: string;
+            computedSource?: string;
+            ast: import("@shaderfrog/glsl-parser/ast").AstNode | Program;
+            inputs?: NodeInput[];
+            inputFillers: import("./strategy").InputFillers;
+            errors?: import("./graph/context").NodeErrors;
+            mainFn?: import("@shaderfrog/glsl-parser/ast").FunctionNode;
+        };
+    };
+    engine: string;
+    runtime: any;
+    debuggingNonsense: {
+        vertexSource?: string;
+        vertexPreprocessed?: string;
+        fragmentPreprocessed?: string;
+        fragmentSource?: string;
+    };
+};
+export declare const extendNodesContext: (context: EngineContext, nodesContext: NodeContexts) => {
+    nodes: {
+        [x: string]: NodeContext;
+    };
+    engine: string;
     runtime: any;
     debuggingNonsense: {
         vertexSource?: string;
@@ -42,7 +77,9 @@ export type EngineContext = {
     };
 };
 export type EngineImporter = {
-    convertAst(ast: Program, type?: ShaderStage): void;
+    convertAst(ast: Program, options?: Record<string, unknown> & {
+        type?: ShaderStage;
+    }): void;
     nodeInputMap: Partial<Record<EngineNodeType, Record<string, string | null>>>;
     edgeMap: {
         [oldInput: string]: string;

package/engine.js

@@ -56,6 +56,11 @@ export var EngineNodeType;
     EngineNodeType["shader"] = "shader";
     EngineNodeType["binary"] = "binary";
 })(EngineNodeType || (EngineNodeType = {}));
+export var extendNodeContext = function (context, nodeId, nodeContext) {
+    var _a;
+    return (__assign(__assign({}, context), { nodes: __assign(__assign({}, context.nodes), (_a = {}, _a[nodeId] = __assign(__assign({}, (context.nodes[nodeId] || {})), nodeContext), _a)) }));
+};
+export var extendNodesContext = function (context, nodesContext) { return (__assign(__assign({}, context), { nodes: __assign(__assign({}, context.nodes), nodesContext) })); };
 // type EdgeUpdates = { [edgeId: string]: { oldInput: string; newInput: string } };
 export var convertNode = function (node, converter) {
     log("Converting ".concat(node.name, " (").concat(node.id, ")"));
@@ -66,8 +71,8 @@ export var convertNode = function (node, converter) {
             define: function () { return true; },
         },
     });
-    var ast = parser.parse(preprocessed);
-    converter.convertAst(ast, node.stage);
+    var ast = parser.parse(preprocessed, { stage: node.stage });
+    converter.convertAst(ast, { type: node.stage });
     var source = generate(ast);
     return __assign(__assign({}, node), { source: source });
 };

package/graph/context.d.ts

@@ -1,4 +1,4 @@
-import { type GlslSyntaxError } from '@shaderfrog/glsl-parser';
+import { GlslSyntaxError } from '@shaderfrog/glsl-parser';
 import { AstNode, FunctionNode, Program } from '@shaderfrog/glsl-parser/ast';
 import { Engine, EngineContext } from '../engine';
 import { NodeInput } from './base-node';
@@ -12,27 +12,28 @@ import { InputFillers } from '../strategy';
 export type NodeContext = {
     id?: string;
     name?: string;
-    source?: string;
+    computedSource?: string;
     ast: AstNode | Program;
     inputs?: NodeInput[];
     inputFillers: InputFillers;
     errors?: NodeErrors;
     mainFn?: FunctionNode;
 };
+export type NodeContexts = Record<string, NodeContext>;
 export type NodeErrors = {
     type: 'errors';
     nodeId: string;
     errors: (GlslSyntaxError | string)[];
 };
 export declare const isError: (test: any) => test is NodeErrors;
-export declare const computeContextForNodes: (engineContext: EngineContext, engine: Engine, graph: Graph, nodes: GraphNode[]) => Promise<NodeErrors | Record<string, NodeContext>>;
+export declare const computeContextForNodes: (engineContext: EngineContext, engine: Engine, graph: Graph, nodes: GraphNode[]) => Promise<NodeErrors | NodeContexts>;
 /**
  * Compute the context for every node in the graph, done on initial graph load
  * to compute the inputs/outputs for every node
  */
-export declare const computeAllContexts: (engineContext: EngineContext, engine: Engine, graph: Graph) => Promise<NodeErrors | undefined>;
+export declare const computeAllContexts: (engineContext: EngineContext, engine: Engine, graph: Graph) => Promise<NodeErrors | NodeContexts>;
 /**
  * Compute the contexts for nodes starting from the outputs, working backwards.
  * Used to only (re)-compute context for any actively used nodes
  */
-export declare const computeGraphContext: (engineContext: EngineContext, engine: Engine, graph: Graph) => Promise<NodeErrors | undefined>;
+export declare const computeGraphContext: (engineContext: EngineContext, engine: Engine, graph: Graph) => Promise<NodeErrors | NodeContexts>;

package/graph/context.js

@@ -71,6 +71,7 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     return to.concat(ar || Array.prototype.slice.call(from));
 };
 import groupBy from 'lodash.groupby';
+import { extendNodeContext, extendNodesContext, } from '../engine';
 import { mapInputName, SourceType } from './code-nodes';
 import { NodeType } from './graph-types';
 import { collectConnectedNodes, filterGraphFromNode, findLinkedNode, findLinkedVertexNodes, isSourceNode, mangleEntireProgram, shouldNodeHaveMainFn, } from './graph';
@@ -98,28 +99,32 @@ var collapseNodeInputs = function (node, updatedInputs) {
     return Object.values(groupBy(__spreadArray(__spreadArray([], __read(updatedInputs), false), __read(node.inputs), false), function (i) { return i.id; })).map(function (dupes) { return dupes.reduce(function (node, dupe) { return (__assign(__assign({}, node), dupe)); }); });
 };
 var computeNodeContext = function (engineContext, engine, graph, node) { return __awaiter(void 0, void 0, void 0, function () {
-    var parser, sibling, onBeforeCompile, manipulateAst, inputEdges, mainFn, ast, dataInputs, computedInputs, nodeContext;
+    var parser, sibling, onBeforeCompile, manipulateAst, updatedNodeContext, updatedContext, inputEdges, mainFn, ast, dataInputs, computedInputs, nodeContext;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
                 parser = __assign(__assign({}, (coreParsers[node.type] || coreParsers[NodeType.SOURCE])), (engine.parsers[node.type] || {}));
                 sibling = findLinkedNode(graph, node.id);
                 onBeforeCompile = parser.onBeforeCompile, manipulateAst = parser.manipulateAst;
+                updatedContext = engineContext;
                 if (!onBeforeCompile) return [3 /*break*/, 2];
                 return [4 /*yield*/, onBeforeCompile(graph, engineContext, node, sibling)];
             case 1:
-                _a.sent();
+                updatedNodeContext = _a.sent();
+                if (updatedNodeContext) {
+                    updatedContext = extendNodeContext(engineContext, node.id, updatedNodeContext);
+                }
                 _a.label = 2;
             case 2:
                 inputEdges = graph.edges.filter(function (edge) { return edge.to === node.id; });
                 try {
-                    ast = parser.produceAst(engineContext, engine, graph, node, inputEdges);
+                    ast = parser.produceAst(updatedContext, engine, graph, node, inputEdges);
                     // Find the main function before mangling
                     if (shouldNodeHaveMainFn(node)) {
                         mainFn = findMain(ast);
                     }
                     if (manipulateAst) {
-                        ast = manipulateAst(engineContext, engine, graph, ast, inputEdges, node, sibling);
+                        ast = manipulateAst(updatedContext, engine, graph, ast, inputEdges, node, sibling);
                     }
                 }
                 catch (error) {
@@ -131,16 +136,21 @@ var computeNodeContext = function (engineContext, engine, graph, node) { return
                         return input.bakeable && (fromNode === null || fromNode === void 0 ? void 0 : fromNode.type) === 'source';
                     },
                 }, 1).inputs[node.id] || [], 'id');
-                computedInputs = parser.findInputs(engineContext, ast, inputEdges, node, sibling);
+                computedInputs = parser.findInputs(updatedContext, ast, inputEdges, node, sibling);
                 node.inputs = collapseNodeInputs(node, computedInputs.map(function (_a) {
                     var _b = __read(_a, 1), i = _b[0];
                     return (__assign(__assign({}, i), { displayName: mapInputName(node, i) }));
                 })).map(function (input) { return (__assign(__assign({}, input), (input.id in dataInputs ? { baked: true } : {}))); });
-                nodeContext = {
-                    ast: ast,
-                    id: node.id,
-                    mainFn: mainFn,
-                    inputFillers: computedInputs.reduce(function (acc, _a) {
+                // Skip mangling if the node tells us to, which probably means it's an engine
+                // node where we don't care about renaming all the variables, or if it's
+                // an expression, where we want to be in the context of other variables
+                // TODO: Use global undefined engine variables here?
+                if (node.config.mangle !== false &&
+                    node.sourceType !== SourceType.EXPRESSION &&
+                    node.sourceType !== SourceType.FN_BODY_FRAGMENT) {
+                    mangleEntireProgram(engine, ast, node, findLinkedNode(graph, node.id));
+                }
+                nodeContext = __assign(__assign({}, (updatedNodeContext || {})), { ast: ast, id: node.id, mainFn: mainFn, inputFillers: computedInputs.reduce(function (acc, _a) {
                         var _b;
                         var _c = __read(_a, 4), input = _c[0], filler = _c[1], fillerArgs = _c[2], fillerStmt = _c[3];
                         // This is intentionally broken out into an explicit return to force
@@ -153,17 +163,7 @@ var computeNodeContext = function (engineContext, engine, graph, node) { return
                             fillerStmt: fillerStmt,
                         };
                         return __assign(__assign({}, acc), (_b = {}, _b[input.id] = fillerGroup, _b));
-                    }, {}),
-                };
-                // Skip mangling if the node tells us to, which probably means it's an engine
-                // node where we don't care about renaming all the variables, or if it's
-                // an expression, where we want to be in the context of other variables
-                // TODO: Use global undefined engine variables here?
-                if (node.config.mangle !== false &&
-                    node.sourceType !== SourceType.EXPRESSION &&
-                    node.sourceType !== SourceType.FN_BODY_FRAGMENT) {
-                    mangleEntireProgram(engine, ast, node, findLinkedNode(graph, node.id));
-                }
+                    }, {}) });
                 return [2 /*return*/, nodeContext];
         }
     });
@@ -174,22 +174,22 @@ export var computeContextForNodes = function (engineContext, engine, graph, node
                 .filter(isSourceNode)
                 .reduce(function (ctx, node) { return __awaiter(void 0, void 0, void 0, function () {
                 var context, nodeContextOrError;
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
+                var _a;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
                         case 0: return [4 /*yield*/, ctx];
                         case 1:
-                            context = _a.sent();
+                            context = _b.sent();
                             if (isError(context)) {
                                 return [2 /*return*/, context];
                             }
                             return [4 /*yield*/, computeNodeContext(engineContext, engine, graph, node)];
                         case 2:
-                            nodeContextOrError = _a.sent();
+                            nodeContextOrError = _b.sent();
                             if (isError(nodeContextOrError)) {
                                 return [2 /*return*/, nodeContextOrError];
                             }
-                            context[node.id] = __assign(__assign({}, (context[node.id] || {})), nodeContextOrError);
-                            return [2 /*return*/, context];
+                            return [2 /*return*/, __assign(__assign({}, context), (_a = {}, _a[node.id] = __assign(__assign({}, (context[node.id] || {})), nodeContextOrError), _a))];
                     }
                 });
             }); }, Promise.resolve(engineContext.nodes))];
@@ -199,26 +199,18 @@ export var computeContextForNodes = function (engineContext, engine, graph, node
  * Compute the context for every node in the graph, done on initial graph load
  * to compute the inputs/outputs for every node
  */
-export var computeAllContexts = function (engineContext, engine, graph) { return __awaiter(void 0, void 0, void 0, function () {
-    var result;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0: return [4 /*yield*/, computeContextForNodes(engineContext, engine, graph, graph.nodes)];
-            case 1:
-                result = _a.sent();
-                if (isError(result)) {
-                    return [2 /*return*/, result];
-                }
-                return [2 /*return*/];
-        }
-    });
-}); };
+export var computeAllContexts = function (engineContext, engine, graph) { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+    switch (_a.label) {
+        case 0: return [4 /*yield*/, computeContextForNodes(engineContext, engine, graph, graph.nodes)];
+        case 1: return [2 /*return*/, _a.sent()];
+    }
+}); }); };
 /**
  * Compute the contexts for nodes starting from the outputs, working backwards.
  * Used to only (re)-compute context for any actively used nodes
  */
 export var computeGraphContext = function (engineContext, engine, graph) { return __awaiter(void 0, void 0, void 0, function () {
-    var outputFrag, outputVert, vertexes, fragments, vertexIds, unlinkedNodes, vertNodesOrError, fragNodesOrError;
+    var outputFrag, outputVert, vertexes, fragments, vertexIds, unlinkedNodes, vertNodesOrError, updatedContext, finalNodeContextOrError;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
@@ -242,15 +234,13 @@ export var computeGraphContext = function (engineContext, engine, graph) { retur
                 if (isError(vertNodesOrError)) {
                     return [2 /*return*/, vertNodesOrError];
                 }
-                return [4 /*yield*/, computeContextForNodes(engineContext, engine, graph, __spreadArray([
+                updatedContext = extendNodesContext(engineContext, vertNodesOrError);
+                return [4 /*yield*/, computeContextForNodes(updatedContext, engine, graph, __spreadArray([
                         outputFrag
                     ], __read(Object.values(fragments).filter(function (node) { return node.id !== outputFrag.id && !vertexIds.has(node.id); })), false))];
             case 2:
-                fragNodesOrError = _a.sent();
-                if (isError(fragNodesOrError)) {
-                    return [2 /*return*/, fragNodesOrError];
-                }
-                return [2 /*return*/];
+                finalNodeContextOrError = _a.sent();
+                return [2 /*return*/, finalNodeContextOrError];
         }
     });
 }); };

package/graph/data-nodes.d.ts

@@ -20,17 +20,26 @@ export declare const numberNode: (id: string, name: string, position: NodePositi
 }) => NumberNode;
 export type NumberDataUniform = Pick<NumberNode, 'type' | 'value' | 'name' | 'range' | 'stepper'>;
 export declare const numberUniformData: (name: string, value: string, range?: [string | number, string | number], stepper?: string | number) => NumberDataUniform;
-export type AssetVersionNodeData = {
-    assetId: number;
-    versionId: number;
+export type TextureNodeValueData = {
+    assetId?: number;
+    versionId?: number;
+    properties?: {
+        repeatTexure: boolean;
+        repeat?: {
+            x: number;
+            y: number;
+        };
+        anisotropy?: number;
+        encoding?: 'srgb';
+    };
 };
 export interface TextureNode extends BaseNode {
     type: 'texture';
-    value?: AssetVersionNodeData;
+    value?: TextureNodeValueData;
 }
-export declare const textureNode: (id: string, name: string, position: NodePosition, value: AssetVersionNodeData) => TextureNode;
+export declare const textureNode: (id: string, name: string, position: NodePosition, value?: TextureNodeValueData) => TextureNode;
 export type TextureDataUniform = Pick<TextureNode, 'type' | 'value' | 'name'>;
-export declare const textureUniformData: (name: string, value: AssetVersionNodeData) => TextureDataUniform;
+export declare const textureUniformData: (name: string, value: TextureNodeValueData) => TextureDataUniform;
 export interface SamplerCubeNode extends BaseNode {
     type: 'samplerCube';
     value: string;

package/graph/data-nodes.js

@@ -40,7 +40,7 @@ export var textureNode = function (id, name, position, value) { return ({
     id: id,
     name: name,
     position: position,
-    value: value,
+    value: __assign(__assign({}, (value || { assetId: undefined, versionId: undefined })), { properties: (value === null || value === void 0 ? void 0 : value.properties) || { repeatTexure: true } }),
     inputs: [],
     outputs: [
         {

package/graph/graph-types.d.ts

@@ -4,12 +4,11 @@ import { SourceNode } from './code-nodes';
 /**
  * Core graph types.
  *
- * Originally abstracted out of graph.ts to avoid a circular
- * dependency between graph.ts and parsers.ts. Both files need these types at
- * module initialization time, and without this third file, the types will be
- * undefined in either graph/parsers.ts at init time. If the types were only
- * used at runtime it would be fine, because the circular depenency is resolved
- * by then.
+ * Originally abstracted out of graph.ts to avoid a circular dependency between
+ * graph.ts and parsers.ts. Both files need these types at module initialization
+ * time, and without this third file, the types will be undefined in either
+ * graph/parsers.ts at init time. If the types were only used at runtime it
+ * would be fine, because the circular depenency is resolved by then.
  */
 export type ShaderStage = 'fragment' | 'vertex';
 /**
@@ -35,4 +34,25 @@ export interface Graph {
     nodes: GraphNode[];
     edges: Edge[];
 }
+export type EdgesByNode = {
+    [nodeId: string]: {
+        from: Edge[];
+        to: {
+            edges: Edge[];
+            edgesByInput: {
+                [inputId: string]: Edge;
+            };
+        };
+    };
+};
+export type Grindex = {
+    nodes: {
+        [nodeId: string]: GraphNode;
+    };
+    edges: {
+        [edgeId: string]: Edge;
+    };
+    edgesByNode: EdgesByNode;
+};
+export declare const computeGrindex: (graph: Graph) => Grindex;
 export declare const MAGIC_OUTPUT_STMTS = "mainStmts";

package/graph/graph-types.js

@@ -1,3 +1,40 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import indexById from '../util/indexByid';
 /**
  * The type applied to the edge representing a link between node stages
  */
@@ -19,4 +56,36 @@ export var NodeType;
     NodeType["BINARY"] = "binary";
     NodeType["SOURCE"] = "source";
 })(NodeType || (NodeType = {}));
+var lastGraph;
+var lastGrindex;
+export var computeGrindex = function (graph) {
+    // Poor programmer's memoization
+    if (graph === lastGraph && lastGrindex) {
+        return lastGrindex;
+    }
+    lastGraph = graph;
+    lastGrindex = {
+        nodes: indexById(graph.nodes),
+        edges: indexById(graph.edges),
+        edgesByNode: graph.edges.reduce(function (acc, edge) {
+            var _a, _b, _c;
+            var _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
+            var to = edge.to, from = edge.from;
+            return __assign(__assign({}, acc), (_a = {}, _a[to] = {
+                to: {
+                    edges: __spreadArray(__spreadArray([], __read((((_e = (_d = acc[to]) === null || _d === void 0 ? void 0 : _d.to) === null || _e === void 0 ? void 0 : _e.edges) || [])), false), [edge], false),
+                    edgesByInput: __assign(__assign({}, (_g = (_f = acc[to]) === null || _f === void 0 ? void 0 : _f.to) === null || _g === void 0 ? void 0 : _g.edgesByInput), (_b = {}, _b[edge.input] = edge, _b)),
+                },
+                from: ((_h = acc[to]) === null || _h === void 0 ? void 0 : _h.from) || [],
+            }, _a[from] = {
+                to: {
+                    edges: ((_k = (_j = acc[from]) === null || _j === void 0 ? void 0 : _j.to) === null || _k === void 0 ? void 0 : _k.edges) || [],
+                    edgesByInput: __assign(__assign({}, (_m = (_l = acc[from]) === null || _l === void 0 ? void 0 : _l.to) === null || _m === void 0 ? void 0 : _m.edgesByInput), (_c = {}, _c[edge.input] = edge, _c)),
+                },
+                from: __spreadArray(__spreadArray([], __read((((_o = acc[from]) === null || _o === void 0 ? void 0 : _o.from) || [])), false), [edge], false),
+            }, _a));
+        }, {}),
+    };
+    return lastGrindex;
+};
 export var MAGIC_OUTPUT_STMTS = 'mainStmts';

package/graph/graph.d.ts

@@ -1,6 +1,6 @@
 import { Program } from '@shaderfrog/glsl-parser/ast';
 import { Engine, EngineContext } from '../engine';
-import { NodeErrors } from './context';
+import { NodeContexts, NodeErrors } from './context';
 import { ShaderSections } from './shader-sections';
 import { FrogProgram } from '../util/ast';
 import { DataNode } from './data-nodes';
@@ -26,7 +26,30 @@ export declare const mangleEntireProgram: (engine: Engine, ast: FrogProgram, nod
 export declare const mangleMainFn: (ast: Program, node: GraphNode, sibling?: GraphNode) => void;
 export declare const ensureFromNode: (graph: Graph, inputEdge: Edge) => import("./data-nodes").NumberNode | import("./data-nodes").TextureNode | import("./data-nodes").SamplerCubeNode | import("./data-nodes").ArrayNode | import("./data-nodes").Vector2Node | import("./data-nodes").Vector3Node | import("./data-nodes").Vector4Node | import("./data-nodes").RgbNode | import("./data-nodes").RgbaNode | import("./code-nodes").BinaryNode | CodeNode;
 export declare const resetGraphIds: (graph: Graph) => Graph;
-export declare const findLinkedNode: (graph: Graph, id: string) => SourceNode | undefined;
+/**
+ * A binary node automatically adds/removes inputs based on how many edges
+ * connect to it. If a binary node has edges to "a" and "b", removing the edge
+ * to "a" means the edge to "b" needs to be moved down to the "a" one. This
+ * function essentially groups edges by target node id, and resets the edge
+ * target to its index. This doesn't feel good to do here but I don't have a
+ * better idea at the moment. One reason the inputs to binary nodes are
+ * automatically updated after compile, but the edges are updated here
+ * at the editor layer, before compile. This also hard codes assumptions about
+ * (binary) node inputs into the graph, namely they can't have blank inputs.
+ */
+export declare const collapseBinaryGraphEdges: (graph: Graph) => Graph;
+/**
+ * Restrict edges so that an input handle can't have multiple edges going to it
+ */
+export declare const addEdgeAndPruneRestrictions: (edges: Edge[], newEdge: Edge) => Edge[];
+/**
+ * Adds an edge to the graph and enforces graph edge business logic rules:
+ * - Makes sure "binary" (add/multiply) nodes edges are collapsed
+ * - Makes sure two edges can't flow into the same input.
+ * See also editor/flow-helpers.ts
+ */
+export declare const addGraphEdge: (graph: Graph, newEdge: Edge) => Graph;
+export declare const findLinkedNode: (graph: Graph, nodeId: string) => SourceNode | undefined;
 /**
  * Find any unconnected vertex nodes linked to collected fragment nodes
  */
@@ -39,7 +62,7 @@ export type Predicates = {
 export type SearchResult = {
     nodes: Record<string, GraphNode>;
     inputs: Record<string, NodeInput[]>;
-    edges: Edge[];
+    edges: Record<string, Edge>;
 };
 export declare const consSearchResult: () => SearchResult;
 export declare const mergeSearchResults: (a: SearchResult, b: SearchResult) => SearchResult;
@@ -86,11 +109,13 @@ export declare const compileGraph: (engineContext: EngineContext, engine: Engine
 export declare const collectNodeProperties: (graph: Graph) => SearchResult;
 export type IndexedDataInputs = Record<string, NodeInput[]>;
 export type CompileResult = {
+    updatedNodeContext: NodeContexts;
     fragmentResult: string;
     vertexResult: string;
     compileResult: CompileGraphResult;
     dataNodes: Record<string, GraphNode>;
     dataInputs: IndexedDataInputs;
+    compileMs: string;
 };
 export declare const compileSource: (graph: Graph, engine: Engine, ctx: EngineContext) => Promise<CompileResult | NodeErrors>;
 export {};