@shaderfrog/core 0.0.2 → 0.1.1

package/dist/ast/shader-sections.js

@@ -0,0 +1,256 @@
+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 { generate } from '@shaderfrog/glsl-parser';
+import { makeStatement } from './manipulate';
+export var emptyShaderSections = function () { return ({
+    precision: [],
+    preprocessor: [],
+    version: [],
+    structs: [],
+    program: [],
+    inStatements: [],
+    outStatements: [],
+    uniforms: [],
+}); };
+var Precision;
+(function (Precision) {
+    Precision[Precision["highp"] = 2] = "highp";
+    Precision[Precision["mediump"] = 1] = "mediump";
+    Precision[Precision["lowp"] = 0] = "lowp";
+})(Precision || (Precision = {}));
+export var higherPrecision = function (p1, p2) {
+    return Precision[p1] > Precision[p2] ? p1 : p2;
+};
+export var dedupeVersions = function (nodes) { return nodes[0]; };
+export var highestPrecisions = function (nodes) {
+    return Object.entries(nodes.reduce(function (precisions, stmt) {
+        var _a;
+        return (__assign(__assign({}, precisions), (_a = {}, _a[stmt.declaration.specifier.specifier.token] = higherPrecision(precisions[stmt.declaration.specifier.specifier.token], stmt.declaration.qualifier.token), _a)));
+    }, {})).map(function (_a) {
+        var _b = __read(_a, 2), typeName = _b[0], precision = _b[1];
+        return makeStatement("precision ".concat(precision, " ").concat(typeName));
+    });
+};
+export var dedupeQualifiedStatements = function (statements, qualifier) {
+    return Object.entries(statements.reduce(function (stmts, stmt) {
+        var _a;
+        return (__assign(__assign({}, stmts), (_a = {}, _a[stmt.declaration.specified_type.specifier.specifier.token] = __assign(__assign({}, (stmts[stmt.declaration.specified_type.specifier.specifier.token] || {})), stmt.declaration.declarations.reduce(function (types, decl) {
+            var _a;
+            return (__assign(__assign({}, types), (_a = {}, _a[decl.identifier.identifier] = true, _a)));
+        }, {})), _a)));
+    }, {})).map(function (_a) {
+        var _b = __read(_a, 2), type = _b[0], varNames = _b[1];
+        return makeStatement("".concat(qualifier, " ").concat(type, " ").concat(Object.keys(varNames).join(', ')));
+    });
+};
+/**
+ * Merge uniforms together into lists of identifiers under the same type.
+ * There's special case handling for mixing of uniforms with "interface blocks"
+ * and those without when merging to make sure the interface block definition is
+ * preserved. Check out the tests for more.
+ *
+ * This function consumes uniforms as found by findShaderSections, so the
+ * definitions must line up
+ */
+export var dedupeUniforms = function (statements) {
+    var groupedByTypeName = Object.entries(statements.reduce(function (stmts, stmt) {
+        var _a, _b, _c;
+        var _d;
+        var decl = stmt.declaration;
+        // This is the standard case, a uniform like "uniform vec2 x"
+        if ('specified_type' in decl) {
+            var specified_type = decl.specified_type;
+            var specifier = specified_type.specifier.specifier;
+            // Token is for "vec2", "identifier" is for custom names like struct
+            var type_1 = 'token' in specifier
+                ? specifier.token
+                : 'identifier' in specifier
+                    ? specifier.identifier
+                    : undefined;
+            if (!type_1) {
+                console.error('Unknown statement: ', stmt);
+                throw new Error("Unknown specifier: ".concat(specifier.type));
+            }
+            // Groups uniforms into their return type, and for each type, collapses
+            // uniform names into an object where the keys determine uniqueness
+            // "vec2": { x: x[1] }
+            var grouped = decl.declarations.reduce(function (types, decl) {
+                var _a;
+                var _b, _c, _d;
+                var identifier = decl.identifier;
+                var quantifier = '';
+                if (decl.quantifier) {
+                    if (!('token' in decl.quantifier[0].expression)) {
+                        console.error('Unknown expression in quantifier: ', decl);
+                        throw new Error("Unknown expression in quantifier: ".concat(generate(decl)));
+                    }
+                    quantifier = "[".concat(decl.quantifier[0].expression.token, "]");
+                }
+                return __assign(__assign({}, types), (_a = {}, _a[identifier.identifier] = ((_c = (_b = stmts[type_1]) === null || _b === void 0 ? void 0 : _b[identifier.identifier]) === null || _c === void 0 ? void 0 : _c.hasInterface)
+                    ? (_d = stmts[type_1]) === null || _d === void 0 ? void 0 : _d[identifier.identifier]
+                    : {
+                        hasInterface: false,
+                        generated: identifier.identifier + quantifier,
+                    }, _a));
+            }, {});
+            return __assign(__assign({}, stmts), (_a = {}, _a[type_1] = __assign(__assign({}, (stmts[type_1] || {})), grouped), _a));
+            // This is the less common case, a uniform like "uniform Light { vec3 position; } name"
+        }
+        else if ('interface_type' in decl) {
+            var interface_type = decl.interface_type, identifier = decl.identifier;
+            // If this is an interface block only, like uniform Scene { mat4 view; };
+            // then group the interface block declaration under ''
+            var interfaceDeclaredUniform = ((_d = identifier === null || identifier === void 0 ? void 0 : identifier.identifier) === null || _d === void 0 ? void 0 : _d.identifier) || '';
+            var node = {
+                type: 'interface_declarator',
+                lp: decl.lp,
+                declarations: decl.declarations,
+                qualifiers: [],
+                // This is non-nullable, to produce "X" in "uniform X { ... } varName"
+                // But it appears "X" is in declarations above
+                interface_type: {
+                    type: 'identifier',
+                    identifier: '',
+                    whitespace: '',
+                },
+                rp: decl.rp,
+            };
+            return __assign(__assign({}, stmts), (_b = {}, _b[interface_type.identifier] = (_c = {},
+                _c[interfaceDeclaredUniform] = {
+                    generated: "".concat(generate(node)).concat(interfaceDeclaredUniform),
+                    hasInterface: true,
+                },
+                _c), _b));
+        }
+        else {
+            console.error('Unknown uniform AST', { stmt: stmt, code: generate(stmt) });
+            throw new Error('Unknown uniform AST encountered when merging uniforms');
+        }
+    }, {}));
+    return groupedByTypeName.map(function (_a) {
+        var _b = __read(_a, 2), type = _b[0], variables = _b[1];
+        return makeStatement("uniform ".concat(type, " ").concat(Object.values(variables)
+            .map(function (v) { return v.generated; })
+            .join(', ')));
+    });
+};
+export var mergeShaderSections = function (s1, s2) {
+    return {
+        version: __spreadArray(__spreadArray([], __read(s1.version), false), __read(s2.version), false),
+        precision: __spreadArray(__spreadArray([], __read(s1.precision), false), __read(s2.precision), false),
+        preprocessor: __spreadArray(__spreadArray([], __read(s1.preprocessor), false), __read(s2.preprocessor), false),
+        inStatements: __spreadArray(__spreadArray([], __read(s1.inStatements), false), __read(s2.inStatements), false),
+        outStatements: __spreadArray(__spreadArray([], __read(s1.outStatements), false), __read(s2.outStatements), false),
+        structs: __spreadArray(__spreadArray([], __read(s1.structs), false), __read(s2.structs), false),
+        uniforms: __spreadArray(__spreadArray([], __read(s1.uniforms), false), __read(s2.uniforms), false),
+        program: __spreadArray(__spreadArray([], __read(s1.program), false), __read(s2.program), false),
+    };
+};
+export var shaderSectionsToProgram = function (sections, mergeOptions) { return ({
+    type: 'program',
+    scopes: [],
+    program: __spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], __read((mergeOptions.includeVersion ? [dedupeVersions(sections.version)] : [])), false), __read((mergeOptions.includePrecisions
+        ? highestPrecisions(sections.precision)
+        : [])), false), __read(sections.preprocessor), false), __read(sections.structs), false), __read(dedupeQualifiedStatements(sections.inStatements, 'in')), false), __read(dedupeQualifiedStatements(sections.outStatements, 'out')), false), __read(dedupeUniforms(sections.uniforms)), false), __read(sections.program), false),
+}); };
+/**
+ * Group an AST into logical sections. The output of this funciton is consumed
+ * by the dedupe methods, namely dedupeUniforms, so the data shapes are coupled
+ */
+export var findShaderSections = function (ast) {
+    var initialValue = {
+        precision: [],
+        preprocessor: [],
+        version: [],
+        structs: [],
+        inStatements: [],
+        outStatements: [],
+        uniforms: [],
+        program: [],
+    };
+    return ast.program.reduce(function (sections, node) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
+        if (node.type === 'preprocessor' && node.line.startsWith('#version')) {
+            return __assign(__assign({}, sections), { version: sections.version.concat(node) });
+        }
+        else if (node.type === 'declaration_statement' &&
+            node.declaration.type === 'precision') {
+            return __assign(__assign({}, sections), { precision: sections.precision.concat(node) });
+        }
+        else if (node.type === 'preprocessor') {
+            return __assign(__assign({}, sections), { preprocessor: sections.preprocessor.concat(node) });
+        }
+        else if (node.type === 'declaration_statement' &&
+            node.declaration.type === 'declarator_list' &&
+            ((_d = (_c = (_b = (_a = node.declaration) === null || _a === void 0 ? void 0 : _a.specified_type) === null || _b === void 0 ? void 0 : _b.specifier) === null || _c === void 0 ? void 0 : _c.specifier) === null || _d === void 0 ? void 0 : _d.type) === 'struct') {
+            return __assign(__assign({}, sections), { structs: sections.structs.concat(node) });
+            // This definition of a uniform lines up with the processing we do in
+            // dedupeUniforms
+        }
+        else if (node.type === 'declaration_statement' &&
+            // Ignore lines like "layout(std140,column_major) uniform;"
+            !('qualifiers' in node.declaration &&
+                ((_f = (_e = node.declaration) === null || _e === void 0 ? void 0 : _e.qualifiers) === null || _f === void 0 ? void 0 : _f.find(function (q) { return 'layout' in q; }))) &&
+            // One of these checks is for a uniform with an interface block, and the
+            // other is for vanilla uniforms. I don't remember which is which
+            (('specified_type' in node.declaration &&
+                'qualifiers' in node.declaration.specified_type &&
+                ((_g = node.declaration.specified_type.qualifiers) === null || _g === void 0 ? void 0 : _g.find(function (n) { return 'token' in n && n.token === 'uniform'; }))) ||
+                ('qualifiers' in node.declaration &&
+                    ((_j = (_h = node.declaration) === null || _h === void 0 ? void 0 : _h.qualifiers) === null || _j === void 0 ? void 0 : _j.find(function (n) { return 'token' in n && n.token === 'uniform'; }))))) {
+            return __assign(__assign({}, sections), { uniforms: sections.uniforms.concat(node) });
+        }
+        else if (node.type === 'declaration_statement' &&
+            'specified_type' in node.declaration &&
+            ((_m = (_l = (_k = node.declaration) === null || _k === void 0 ? void 0 : _k.specified_type) === null || _l === void 0 ? void 0 : _l.qualifiers) === null || _m === void 0 ? void 0 : _m.find(function (n) { return 'token' in n && n.token === 'in'; }))) {
+            if (generate(node).includes('main_Fireball')) {
+                console.log('findShaderSections\n', generate(ast));
+                console.log("Tracking inStatement \"".concat(generate(node), "\""), node);
+                debugger;
+            }
+            return __assign(__assign({}, sections), { inStatements: sections.inStatements.concat(node) });
+        }
+        else if (node.type === 'declaration_statement' &&
+            'specified_type' in node.declaration &&
+            ((_q = (_p = (_o = node.declaration) === null || _o === void 0 ? void 0 : _o.specified_type) === null || _p === void 0 ? void 0 : _p.qualifiers) === null || _q === void 0 ? void 0 : _q.find(function (n) { return 'token' in n && n.token === 'out'; }))) {
+            return __assign(__assign({}, sections), { outStatements: sections.outStatements.concat(node) });
+        }
+        else {
+            return __assign(__assign({}, sections), { program: sections.program.concat(node) });
+        }
+    }, initialValue);
+};

package/dist/context.js

@@ -0,0 +1,230 @@
+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 __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+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 groupBy from 'lodash.groupby';
+import { mapInputName, SourceType, } from './nodes/code-nodes';
+import { NodeType } from './graph-types';
+import { collectConnectedNodes, filterGraphFromNode, isSourceNode, mangleEntireProgram, } from './graph';
+import { coreParsers } from './parsers';
+var makeError = function () {
+    var errors = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        errors[_i] = arguments[_i];
+    }
+    return ({
+        type: 'errors',
+        errors: errors,
+    });
+};
+var isError = function (test) { return (test === null || test === void 0 ? void 0 : test.type) === 'errors'; };
+// Merge existing node inputs, and inputs based on properties, with new ones
+// found from the source code, using the *id* as the uniqueness key. Any filler input gets
+// merged into property inputs with the same id. This preserves the
+// "baked" property on node inputs which is toggle-able in the graph
+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, onBeforeCompile, manipulateAst, groupId_1, sibling, inputEdges, 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] || {}));
+                onBeforeCompile = parser.onBeforeCompile, manipulateAst = parser.manipulateAst;
+                if (!onBeforeCompile) return [3 /*break*/, 2];
+                groupId_1 = node.groupId;
+                sibling = graph.nodes.find(function (n) {
+                    return n !== node && 'groupId' in n && n.groupId === groupId_1;
+                });
+                return [4 /*yield*/, onBeforeCompile(graph, engineContext, node, sibling)];
+            case 1:
+                _a.sent();
+                _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);
+                    if (manipulateAst) {
+                        ast = manipulateAst(engineContext, engine, graph, node, ast, inputEdges);
+                    }
+                }
+                catch (error) {
+                    console.error('Error parsing source code!', { error: error, node: node });
+                    return [2 /*return*/, makeError(error)];
+                }
+                dataInputs = groupBy(filterGraphFromNode(graph, node, {
+                    input: function (input, b, c, fromNode) {
+                        return input.bakeable && (fromNode === null || fromNode === void 0 ? void 0 : fromNode.type) === 'source';
+                    },
+                }, 1).inputs[node.id] || [], 'id');
+                computedInputs = parser.findInputs(engineContext, node, ast, inputEdges);
+                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,
+                    inputFillers: computedInputs.reduce(function (acc, _a) {
+                        var _b;
+                        var _c = __read(_a, 3), input = _c[0], filler = _c[1], args = _c[2];
+                        return (__assign(__assign({}, acc), (_b = {}, _b[input.id] = {
+                            filler: filler,
+                            args: args,
+                        }, _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(ast, node, engine);
+                }
+                return [2 /*return*/, nodeContext];
+        }
+    });
+}); };
+export var computeContextForNodes = function (engineContext, engine, graph, nodes) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        return [2 /*return*/, nodes
+                .filter(isSourceNode)
+                .reduce(function (ctx, node) { return __awaiter(void 0, void 0, void 0, function () {
+                var context, nodeContext;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, ctx];
+                        case 1:
+                            context = _a.sent();
+                            if (isError(context)) {
+                                return [2 /*return*/, context];
+                            }
+                            return [4 /*yield*/, computeNodeContext(engineContext, engine, graph, node)];
+                        case 2:
+                            nodeContext = _a.sent();
+                            if (isError(nodeContext)) {
+                                return [2 /*return*/, makeError(nodeContext)];
+                            }
+                            context[node.id] = __assign(__assign({}, (context[node.id] || {})), nodeContext);
+                            return [2 /*return*/, context];
+                    }
+                });
+            }); }, Promise.resolve(engineContext.nodes))];
+    });
+}); };
+/**
+ * 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 computeContextForNodes(engineContext, engine, graph, graph.nodes); };
+/**
+ * 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, vertexIds, fragmentIds, additionalIds;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                outputFrag = graph.nodes.find(function (node) { return node.type === 'output' && node.stage === 'fragment'; });
+                if (!outputFrag) {
+                    throw new Error('No fragment output in graph');
+                }
+                outputVert = graph.nodes.find(function (node) { return node.type === 'output' && node.stage === 'vertex'; });
+                if (!outputVert) {
+                    throw new Error('No vertex output in graph');
+                }
+                vertexIds = collectConnectedNodes(graph, outputVert);
+                fragmentIds = collectConnectedNodes(graph, outputFrag);
+                additionalIds = graph.nodes.filter(function (node) {
+                    return isSourceNode(node) &&
+                        node.stage === 'vertex' &&
+                        node.nextStageNodeId &&
+                        fragmentIds[node.nextStageNodeId] &&
+                        !vertexIds[node.id];
+                });
+                return [4 /*yield*/, computeContextForNodes(engineContext, engine, graph, __spreadArray(__spreadArray([
+                        outputVert
+                    ], __read(Object.values(vertexIds).filter(function (node) { return node.id !== outputVert.id; })), false), __read(additionalIds), false))];
+            case 1:
+                _a.sent();
+                return [4 /*yield*/, computeContextForNodes(engineContext, engine, graph, __spreadArray([
+                        outputFrag
+                    ], __read(Object.values(fragmentIds).filter(function (node) { return node.id !== outputFrag.id; })), false))];
+            case 2:
+                _a.sent();
+                return [2 /*return*/];
+        }
+    });
+}); };