grafast 0.1.1-beta.21 → 0.1.1-beta.22

package/dist/engine/LayerPlan.js

@@ -1,19 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LayerPlan = void 0;
-exports.isBranchingLayerPlan = isBranchingLayerPlan;
+exports.hasParentLayerPlan = hasParentLayerPlan;
 exports.isDeferredLayerPlan = isDeferredLayerPlan;
-exports.isPolymorphicLayerPlan = isPolymorphicLayerPlan;
 const tslib_1 = require("tslib");
-const lru_1 = tslib_1.__importDefault(require("@graphile/lru"));
-const tamedevil_1 = tslib_1.__importDefault(require("tamedevil"));
 const assert = tslib_1.__importStar(require("../assert.js"));
+const constants_js_1 = require("../constants.js");
+const error_js_1 = require("../error.js");
 const inspect_js_1 = require("../inspect.js");
-const interfaces_js_1 = require("../interfaces.js");
-const polymorphic_js_1 = require("../polymorphic.js");
+const utils_js_1 = require("../utils.js");
 const executeBucket_js_1 = require("./executeBucket.js");
-function isBranchingLayerPlan(layerPlan) {
-    return layerPlan.reason.type === "polymorphic";
+/**
+ * If any of these flags exist on a value then it isn't the value we want to
+ * include for the combo step.
+ */
+const SKIP_FLAGS = constants_js_1.FLAG_ERROR | constants_js_1.FLAG_STOPPED | constants_js_1.FLAG_POLY_SKIPPED | constants_js_1.FLAG_INHIBITED;
+/**
+ * If any of these flags exist on the "$__typename" step, then the value
+ * should resolve to null
+ */
+const NO_TYPENAME_FLAGS = constants_js_1.FLAG_ERROR | constants_js_1.FLAG_STOPPED | constants_js_1.FLAG_POLY_SKIPPED | constants_js_1.FLAG_INHIBITED | constants_js_1.FLAG_NULL;
+function hasParentLayerPlan(reason) {
+    return reason.type !== "root" && reason.type !== "combined";
 }
 function isDeferredLayerPlan(layerPlan) {
     const t = layerPlan.reason.type;
@@ -22,10 +30,6 @@ function isDeferredLayerPlan(layerPlan) {
         t === "mutationField" ||
         t === "defer");
 }
-function isPolymorphicLayerPlan(layerPlan) {
-    const t = layerPlan.reason.type;
-    return t === "polymorphic";
-}
 /**
  * A LayerPlan represents (via "reason") either the root (root), when something
  * happens at a later time (mutationField, defer), when plurality changes
@@ -52,9 +56,11 @@ function isPolymorphicLayerPlan(layerPlan) {
  *
  */
 class LayerPlan {
-    constructor(operationPlan, parentLayerPlan, reason) {
+    constructor(operationPlan, reason) {
+        // This layer plan is dependent on the latest side effect. Note that when
+        // we set a `rootStep` later, if the root step is dependent on this step
+        // (directly or indirectly) we will clear this property.
         this.operationPlan = operationPlan;
-        this.parentLayerPlan = parentLayerPlan;
         this.reason = reason;
         /**
          * Every layer plan has a "root step" that shapes the value the layer
@@ -88,15 +94,6 @@ class LayerPlan {
         this.steps = [];
         /** @internal */
         this.pendingSteps = [];
-        /**
-         * This goes along with `parentStep` in the reason, except it applies to all
-         * layer plan types and we figure it out automatically from the parent layer
-         * plan. If this step has an error at a given index, then it should be
-         * treated as if the parentStep had an error at that same index.
-         *
-         * @internal
-         */
-        this.parentSideEffectStep = null;
         /**
          * This tracks the latest seen side effect at the current point in planning
          * (such that created steps take this to be their implicitSideEffectStep).
@@ -113,15 +110,90 @@ class LayerPlan {
          * @internal
          */
         this.phases = [];
+        // TODO: is it possible for this to go wrong by one of the stream items not
+        // streaming and the other one streaming? Technically the arguments need to
+        // match or it wouldn't be allowed to combine (the planning paths would
+        // differ because they factor in the argument step ids) but what if we
+        // decided to fulfil one without streaming and the other streaming only?
+        /**
+         * Populated during `finalize`, this will be empty except for phase
+         * transition layer plans (defer/stream) wherein it will contain a list of
+         * "unreachable" layer plan IDs relevant to the "combined" layer plans trying
+         * to refer to parent layer plans which are outside of this incremental
+         * boundary (e.g. if two lists both stream, we might combine those, but at
+         * runtime only one will be populated so we can't wait for the other to
+         * complete otherwise nothing will happen).
+         */
+        this.outOfBoundsLayerPlanIds = new Set();
         this._hasSetRootStep = false;
-        // This layer plan is dependent on the latest side effect. Note that when
-        // we set a `rootStep` later, if the root step is dependent on this step
-        // (directly or indirectly) we will clear this property.
-        this.parentSideEffectStep = parentLayerPlan?.latestSideEffectStep ?? null;
+        /** @internal */
+        this.combinations = [];
+        /** @internal */
+        this.finalCombinations = [];
         // There has yet to be any side effects created in this layer.
         this.latestSideEffectStep = null;
         this.stepsByConstructor = new Map();
-        if (parentLayerPlan !== null) {
+        if (reason.type === "root") {
+            this.parentSideEffectStep = null;
+            this.depth = 0;
+            this.ancestry = [this];
+            this.deferBoundaryDepth = 0;
+            this.id = operationPlan.addLayerPlan(this);
+            assert.strictEqual(this.id, 0, "Root layer plan must have id=0, there must be only one");
+        }
+        else if (reason.type === "combined") {
+            this.parentSideEffectStep = null;
+            const firstParentLayerPlan = reason.parentLayerPlans[0];
+            const rootLp = firstParentLayerPlan.ancestry[0];
+            if (rootLp.reason.type !== "root") {
+                throw new Error("GrafastInternalError<e9290db3-9a1b-45af-a50e-baa9e161d7cc>: expected the 0'th entry in ancestry to be the root layer plan");
+            }
+            // TODO: is this calculated correctly?
+            let deferBoundaryDepth = 0;
+            this.ancestry = [];
+            /** Unskipped because it comes from the raw layer plans, we skip over those that don't match */
+            let prevUnskippedDeferBoundaryDepth = 0;
+            for (let i = 0, l = firstParentLayerPlan.ancestry.length; i < l; i++) {
+                const ancestor = firstParentLayerPlan.ancestry[i];
+                let match = true;
+                for (const lp of reason.parentLayerPlans) {
+                    if (lp.ancestry[i] !== ancestor) {
+                        // Shared ancestry fails here
+                        match = false;
+                    }
+                }
+                if (match) {
+                    this.ancestry.push(ancestor);
+                    if (ancestor.deferBoundaryDepth > prevUnskippedDeferBoundaryDepth) {
+                        if (ancestor.deferBoundaryDepth === ancestor.depth) {
+                            // They're the boundary
+                            deferBoundaryDepth = this.ancestry.length - 1;
+                        }
+                        else {
+                            // Treat the previous ancestor as the defer boundary
+                            deferBoundaryDepth = this.ancestry.length - 2;
+                        }
+                        prevUnskippedDeferBoundaryDepth = ancestor.deferBoundaryDepth;
+                    }
+                }
+            }
+            this.ancestry.push(this);
+            this.depth = this.ancestry.length - 1;
+            this.deferBoundaryDepth = deferBoundaryDepth;
+            this.id = operationPlan.addLayerPlan(this);
+            // Deliberately shadow!
+            for (const parentLayerPlan of reason.parentLayerPlans) {
+                parentLayerPlan.children.push(this);
+            }
+        }
+        else {
+            const parentLayerPlan = reason.parentLayerPlan;
+            if (reason.type === "polymorphicPartition") {
+                if (parentLayerPlan.reason.type !== "polymorphic") {
+                    throw new Error(`GrafastInternalError<ef8fcb9a-5252-4593-915c-b3ebe4aa8eff>: a polymorphicPartition may only be a child of a polymorphic layer plan, but ${this} was created under ${parentLayerPlan}`);
+                }
+            }
+            this.parentSideEffectStep = parentLayerPlan.latestSideEffectStep ?? null;
             this.depth = parentLayerPlan.depth + 1;
             this.ancestry = [...parentLayerPlan.ancestry, this];
             if (isDeferredLayerPlan(this)) {
@@ -130,29 +202,27 @@ class LayerPlan {
             else {
                 this.deferBoundaryDepth = parentLayerPlan.deferBoundaryDepth;
             }
-        }
-        else {
-            this.depth = 0;
-            this.ancestry = [this];
-            this.deferBoundaryDepth = 0;
-        }
-        this.id = operationPlan.addLayerPlan(this);
-        if (!parentLayerPlan) {
-            assert.strictEqual(this.id, 0, "All but the first LayerPlan must have a parent");
-        }
-        else {
-            assert.ok(reason.type != "root", "Non-root LayerPlan must have a parentStep");
+            this.id = operationPlan.addLayerPlan(this);
             parentLayerPlan.children.push(this);
         }
     }
     toString() {
         let chain = "";
         // eslint-disable-next-line @typescript-eslint/no-this-alias
+        let prev = this;
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
         let current = this;
-        while ((current = current.parentLayerPlan)) {
+        while ((current = hasParentLayerPlan(current.reason)
+            ? current.reason.parentLayerPlan
+            : null)) {
             chain = chain + `∈${current.id}`;
+            prev = current;
         }
-        const reasonExtra = this.reason.type === "polymorphic"
+        if (prev.reason.type === "combined") {
+            chain =
+                chain + `Σ${prev.reason.parentLayerPlans.map((p) => p.id).join("|")}`;
+        }
+        const reasonExtra = this.reason.type === "polymorphicPartition"
             ? `{${this.reason.typeNames.join(",")}}`
             : "";
         const deps = this.copyStepIds.length > 0 ? `/${this.copyStepIds}` : "";
@@ -185,22 +255,29 @@ class LayerPlan {
         return this.operationPlan._addStep(step);
     }
     finalize() {
-        if (
-        // this.reason.type === "nullableBoundary" ||
-        this.reason.type === "listItem") {
-            const u = this.copyStepIds.length;
-            const signature = `${this.reason.type[0]}_${u}`;
-            withNewBucketFactory(signature, u, this.reason.type, (fn) => {
-                this.newBucket = fn(this.copyStepIds);
-            });
-        }
+        this.finalCombinations = this.combinations.map((c) => {
+            const { targetStepId, sources } = c;
+            const sourceStepsByLayerPlanId = Object.create(null);
+            for (const { layerPlanId, stepId } of sources) {
+                sourceStepsByLayerPlanId[layerPlanId] ??= [];
+                sourceStepsByLayerPlanId[layerPlanId].push(stepId);
+            }
+            return {
+                targetStepId,
+                sourceStepsByLayerPlanId,
+            };
+        });
     }
     newBucket(parentBucket) {
+        if (this.reason.type === "combined") {
+            throw new Error(`Use newCombinedBucket instead.`);
+        }
         const { copyStepIds } = this;
         const store = new Map();
         const polymorphicPathList = this.reason.type === "mutationField"
             ? parentBucket.polymorphicPathList
             : [];
+        const polymorphicType = this.reason.type === "polymorphic" ? [] : null;
         const iterators = this.reason.type === "mutationField" ? parentBucket.iterators : [];
         const map = new Map();
         const $parentSideEffect = this.parentSideEffectStep;
@@ -224,7 +301,7 @@ class LayerPlan {
                 const hasNoNullsOrErrors = false;
                 if (this.rootStep._isUnary) {
                     const fieldValue = parentBucket.store.get(itemStepId);
-                    const forbiddenFlags = fieldValue._entryFlags & interfaces_js_1.FORBIDDEN_BY_NULLABLE_BOUNDARY_FLAGS;
+                    const forbiddenFlags = fieldValue._entryFlags & constants_js_1.FORBIDDEN_BY_NULLABLE_BOUNDARY_FLAGS;
                     if (forbiddenFlags) {
                         size = 0;
                     }
@@ -236,7 +313,7 @@ class LayerPlan {
                         const parentBucketSize = parentBucket.size;
                         for (let originalIndex = 0; originalIndex < parentBucketSize; originalIndex++) {
                             if (parentSideEffectValue === null ||
-                                !(parentSideEffectValue._flagsAt(originalIndex) & interfaces_js_1.FLAG_ERROR)) {
+                                !(parentSideEffectValue._flagsAt(originalIndex) & constants_js_1.FLAG_ERROR)) {
                                 const newIndex = size++;
                                 map.set(originalIndex, newIndex);
                                 polymorphicPathList[newIndex] =
@@ -264,8 +341,8 @@ class LayerPlan {
                     }
                 }
                 else {
-                    const itemStepIdList = [];
-                    store.set(itemStepId, (0, executeBucket_js_1.batchExecutionValue)(itemStepIdList));
+                    const ev = (0, executeBucket_js_1.batchExecutionValue)([]);
+                    store.set(itemStepId, ev);
                     for (const stepId of copyStepIds) {
                         const ev = parentBucket.store.get(stepId);
                         if (ev.isBatch) {
@@ -285,12 +362,11 @@ class LayerPlan {
                     // we must "multiply up" (down) the store entries.
                     for (let originalIndex = 0; originalIndex < parentBucket.size; originalIndex++) {
                         if ((parentSideEffectValue === null ||
-                            !(parentSideEffectValue._flagsAt(originalIndex) & interfaces_js_1.FLAG_ERROR)) &&
-                            !(nullableStepStore._flagsAt(originalIndex) & interfaces_js_1.FLAG_NULL)) {
+                            !(parentSideEffectValue._flagsAt(originalIndex) & constants_js_1.FLAG_ERROR)) &&
+                            !(nullableStepStore._flagsAt(originalIndex) & constants_js_1.FLAG_NULL)) {
                             const newIndex = size++;
                             map.set(originalIndex, newIndex);
-                            const fieldValue = nullableStepStore.at(originalIndex);
-                            itemStepIdList[newIndex] = fieldValue;
+                            ev._copyResult(newIndex, nullableStepStore, originalIndex);
                             polymorphicPathList[newIndex] =
                                 parentBucket.polymorphicPathList[originalIndex];
                             iterators[newIndex] = parentBucket.iterators[originalIndex];
@@ -338,16 +414,26 @@ class LayerPlan {
                 for (let originalIndex = 0; originalIndex < parentBucket.size; originalIndex++) {
                     const list = listStepStore.at(originalIndex);
                     if ((parentSideEffectValue === null ||
-                        !(parentSideEffectValue._flagsAt(originalIndex) & interfaces_js_1.FLAG_ERROR)) &&
+                        !(parentSideEffectValue._flagsAt(originalIndex) & constants_js_1.FLAG_ERROR)) &&
                         Array.isArray(list)) {
                         const newIndexes = [];
                         map.set(originalIndex, newIndexes);
                         for (let j = 0, l = list.length; j < l; j++) {
                             const newIndex = size++;
                             newIndexes.push(newIndex);
-                            ev.entries[newIndex] = list[j];
-                            // TODO: are these the right flags?
-                            ev._flags[newIndex] = list[j] == null ? interfaces_js_1.FLAG_NULL : interfaces_js_1.NO_FLAGS;
+                            let val = list[j];
+                            let flags = constants_js_1.NO_FLAGS;
+                            if (val == null) {
+                                flags = flags | constants_js_1.FLAG_NULL;
+                            }
+                            else if (typeof val === "object" && (0, error_js_1.isFlaggedValue)(val)) {
+                                flags = val.flags;
+                                val = val.value;
+                                if (val == null) {
+                                    flags = flags | constants_js_1.FLAG_NULL;
+                                }
+                            }
+                            ev._setResult(newIndex, val, flags);
                             polymorphicPathList[newIndex] =
                                 parentBucket.polymorphicPathList[originalIndex];
                             iterators[newIndex] = parentBucket.iterators[originalIndex];
@@ -375,20 +461,19 @@ class LayerPlan {
                 break;
             }
             case "polymorphic": {
-                const polymorphicPlanId = this.reason.parentStep.id;
-                const polymorphicPlanStore = parentBucket.store.get(polymorphicPlanId);
-                if (!polymorphicPlanStore) {
-                    throw new Error(`GrafastInternalError<af1417c6-752b-466e-af7e-cfc35724c3bc>: Entry for '${parentBucket.layerPlan.operationPlan.dangerouslyGetStep(polymorphicPlanId)}' not found in bucket for '${parentBucket.layerPlan}'`);
+                const parentStepId = this.reason.parentStep.id;
+                const typenameEV = parentBucket.store.get(parentStepId);
+                if (!typenameEV) {
+                    throw new Error(`GrafastInternalError<af1417c6-752b-466e-af7e-cfc35724c3bc>: Entry for '${parentBucket.layerPlan.operationPlan.dangerouslyGetStep(parentStepId)}' not found in bucket for '${parentBucket.layerPlan}'`);
                 }
-                // We're only copying over the entries that match this type (note:
-                // they may end up being null, but that's okay)
-                const targetTypeNames = this.reason.typeNames;
+                const batchCopyStepIds = [];
                 for (const stepId of copyStepIds) {
                     const ev = parentBucket.store.get(stepId);
                     if (!ev) {
                         throw new Error(`GrafastInternalError<548f0d84-4556-4189-8655-fb16aa3345a6>: new bucket for ${this} wants to copy ${this.operationPlan.dangerouslyGetStep(stepId)}, but bucket for ${parentBucket.layerPlan} doesn't contain that plan`);
                     }
                     if (ev.isBatch) {
+                        batchCopyStepIds.push(stepId);
                         store.set(stepId, (0, executeBucket_js_1.batchExecutionValue)([]));
                     }
                     else {
@@ -396,37 +481,75 @@ class LayerPlan {
                     }
                 }
                 for (let originalIndex = 0; originalIndex < parentBucket.size; originalIndex++) {
-                    const flags = polymorphicPlanStore._flagsAt(originalIndex);
-                    if (flags & (interfaces_js_1.FLAG_ERROR | interfaces_js_1.FLAG_INHIBITED | interfaces_js_1.FLAG_NULL)) {
+                    const flags = typenameEV._flagsAt(originalIndex);
+                    if ((flags & NO_TYPENAME_FLAGS) !== 0) {
                         continue;
                     }
                     if (parentSideEffectValue !== null &&
-                        parentSideEffectValue._flagsAt(originalIndex) & interfaces_js_1.FLAG_ERROR) {
+                        parentSideEffectValue._flagsAt(originalIndex) & constants_js_1.FLAG_ERROR) {
                         continue;
                     }
-                    const value = polymorphicPlanStore.at(originalIndex);
-                    const typeName = (0, polymorphic_js_1.resolveType)(value);
-                    if (!targetTypeNames.includes(typeName)) {
+                    const polymorphicPath = parentBucket.polymorphicPathList.at(originalIndex);
+                    const typeName = typenameEV.at(originalIndex);
+                    if (!this.reason.typeNames.includes(typeName)) {
+                        // Search: InvalidConcreteTypeName
+                        // TODO: should we throw an error?
+                        // Skip
                         continue;
                     }
                     const newIndex = size++;
                     map.set(originalIndex, newIndex);
-                    // PERF: might be faster if we look this up as a constant rather than using concatenation here
-                    const newPolymorphicPath = (parentBucket.polymorphicPathList[originalIndex] ?? "") +
-                        ">" +
-                        typeName;
-                    polymorphicPathList[newIndex] = newPolymorphicPath;
+                    polymorphicPathList[newIndex] =
+                        (polymorphicPath ?? "") + ">" + typeName;
+                    polymorphicType[newIndex] = typeName;
                     iterators[newIndex] = parentBucket.iterators[originalIndex];
-                    for (const planId of copyStepIds) {
+                    for (const planId of batchCopyStepIds) {
                         const ev = store.get(planId);
-                        if (ev.isBatch) {
-                            const orig = parentBucket.store.get(planId);
-                            ev._copyResult(newIndex, orig, originalIndex);
-                        }
+                        const orig = parentBucket.store.get(planId);
+                        ev._copyResult(newIndex, orig, originalIndex);
+                    }
+                }
+                break;
+            }
+            case "polymorphicPartition": {
+                // Similar to polymorphic
+                const batchCopyStepIds = [];
+                for (const stepId of copyStepIds) {
+                    const ev = parentBucket.store.get(stepId);
+                    if (!ev) {
+                        throw new Error(`GrafastInternalError<548f0d84-4556-4189-8655-fb16aa3345a6>: new bucket for ${this} wants to copy ${this.operationPlan.dangerouslyGetStep(stepId)}, but bucket for ${parentBucket.layerPlan} doesn't contain that plan`);
+                    }
+                    if (ev.isBatch) {
+                        batchCopyStepIds.push(stepId);
+                        store.set(stepId, (0, executeBucket_js_1.batchExecutionValue)([]));
+                    }
+                    else {
+                        store.set(stepId, ev);
+                    }
+                }
+                for (let originalIndex = 0; originalIndex < parentBucket.size; originalIndex++) {
+                    if (parentSideEffectValue !== null &&
+                        parentSideEffectValue._flagsAt(originalIndex) & constants_js_1.FLAG_ERROR) {
+                        continue;
+                    }
+                    const typeName = parentBucket.polymorphicType.at(originalIndex);
+                    if (!this.reason.typeNames.includes(typeName)) {
+                        continue;
+                    }
+                    const newIndex = size++;
+                    map.set(originalIndex, newIndex);
+                    polymorphicPathList[newIndex] =
+                        parentBucket.polymorphicPathList.at(originalIndex);
+                    iterators[newIndex] = parentBucket.iterators[originalIndex];
+                    for (const planId of batchCopyStepIds) {
+                        const ev = store.get(planId);
+                        const orig = parentBucket.store.get(planId);
+                        ev._copyResult(newIndex, orig, originalIndex);
                     }
                 }
                 break;
             }
+            // case "combined": See newCombinedBucket below
             case "subscription":
             case "defer": {
                 // TODO
@@ -447,15 +570,16 @@ class LayerPlan {
         }
         if (size > 0) {
             // Reference
-            const childBucket = (0, executeBucket_js_1.newBucket)({
+            const childBucket = (0, executeBucket_js_1.newBucket)(parentBucket, {
                 layerPlan: this,
                 size,
                 store,
                 // PERF: not necessarily, if we don't copy the errors, we don't have the errors.
                 flagUnion: parentBucket.flagUnion,
                 polymorphicPathList,
+                polymorphicType,
                 iterators,
-            }, parentBucket.metaByMetaKey);
+            });
             parentBucket.children[this.id] = {
                 bucket: childBucket,
                 map,
@@ -466,189 +590,175 @@ class LayerPlan {
             return null;
         }
     }
-}
-exports.LayerPlan = LayerPlan;
-const makeNewBucketCache = new lru_1.default({
-    maxLength: 1000,
-});
-const makingNewBucketCallbacks = new Map();
-const te_parentBucketDotPolymorphicPathList = (0, tamedevil_1.default) `parentBucket.polymorphicPathList`;
-const te_parentBucketDotIterators = (0, tamedevil_1.default) `parentBucket.iterators`;
-const te_emptyArray = (0, tamedevil_1.default) `[]`;
-const ref_newBucket = tamedevil_1.default.ref(executeBucket_js_1.newBucket, "newBucket");
-const ref_batchExecutionValue = tamedevil_1.default.ref(executeBucket_js_1.batchExecutionValue, "batchExecutionValue");
-function makeNewBucketExpression(signature, reasonType, inner) {
-    const expr = (0, tamedevil_1.default) `\
-(function ${tamedevil_1.default.identifier(`newBucket_${signature}`)}(parentBucket) {
-  const store = new Map();
-  const polymorphicPathList = ${reasonType === "mutationField"
-        ? te_parentBucketDotPolymorphicPathList
-        : te_emptyArray};
-  const iterators = ${reasonType === "mutationField" ? te_parentBucketDotIterators : te_emptyArray};
-  const map = new Map();
-  let size = 0;
-
-${inner}
-
-  if (size > 0) {
-    // Reference
-    const childBucket = ${ref_newBucket}({
-      layerPlan: this,
-      size,
-      store,
-      // PERF: not necessarily, if we don't copy the errors, we don't have the errors.
-      flagUnion: parentBucket.flagUnion,
-      polymorphicPathList,
-      iterators,
-    }, parentBucket.metaByMetaKey);
-    // PERF: set ourselves in more places so that we never have to call 'getChildBucketAndIndex'.
-    parentBucket.children[this.id] = { bucket: childBucket, map };
-
-    return childBucket;
-  } else {
-    return null;
-  }
-})`;
-    // te.debug(expr);
-    return expr;
-}
-function newBucketFactoryInnerExpression(signature, copyCount, reasonType) {
-    if (reasonType === "nullableBoundary") {
-        if (Math.random() < 2) {
-            throw new Error("This code no longer works since we added unary steps.");
+    newCombinedBucket(finalParentBucket) {
+        const t = this.reason.type;
+        if (t !== "combined") {
+            throw new Error(`GrafastInternalError<59c54cd0-ee32-478a-9e0e-4123eec2f8f5>: newCombinedBucket must only be called on combined layer plans`);
+        }
+        const { sharedState } = finalParentBucket;
+        const { copyStepIds } = this;
+        const store = new Map();
+        const polymorphicPathList = [];
+        const iterators = [];
+        const mapByParentLayerPlanId = Object.create(null);
+        let flagUnion = constants_js_1.NO_FLAGS;
+        let totalSize = 0;
+        const batchStepIdsToCopy = new Set();
+        for (const plp of this.reason.parentLayerPlans) {
+            mapByParentLayerPlanId[plp.id] = new Map();
+            const parentBucket = sharedState._retainedBuckets.get(plp.id);
+            if (!parentBucket)
+                continue;
+            flagUnion |= parentBucket.flagUnion;
+            totalSize += parentBucket.size;
+            const map = mapByParentLayerPlanId[plp.id];
+            for (let i = 0, l = parentBucket.size; i < l; i++) {
+                const sourcePolyPath = parentBucket.polymorphicPathList[i];
+                map.set(i, polymorphicPathList.length);
+                polymorphicPathList.push(sourcePolyPath);
+            }
+            for (const copyStepId of copyStepIds) {
+                if (store.has(copyStepId))
+                    continue;
+                const ev = parentBucket.store.get(copyStepId);
+                if (ev == null) {
+                    // No action
+                    // TODO: do we need a placeholder for not found evs? I don't think so -
+                    // it implies that the dependency bucket doesn't exist and thus nothing
+                    // will use it?
+                }
+                else if (ev.isBatch) {
+                    batchStepIdsToCopy.add(copyStepId);
+                }
+                else {
+                    store.set(copyStepId, ev);
+                }
+            }
         }
-        // PERF: if parent bucket has no nulls/errors in itemStepId
-        // then we can just copy everything wholesale rather than building
-        // new arrays and looping.
-        const blocks = [];
-        const copyBlocks = [];
-        for (let i = 0; i < copyCount; i++) {
-            const te_source = tamedevil_1.default.identifier(`source${i}`);
-            const te_target = tamedevil_1.default.identifier(`target${i}`);
-            const te_i = tamedevil_1.default.lit(i);
-            blocks.push((0, tamedevil_1.default) `\
-  const ${te_source} = parentBucket.store.get(copyStepIds[${te_i}]);
-  const ${te_target} = ${te_source}.isBatch ? ${ref_batchExecutionValue}([]) : ${te_source};
-  store.set(copyStepIds[${te_i}], ${te_target});
-`);
-            copyBlocks.push((0, tamedevil_1.default) `\
-      if(${te_target}.isBatch) {
-        ${te_target}.entries[newIndex] = ${te_source}.at(originalIndex);
-      }
-`);
+        if (totalSize === 0)
+            return null;
+        for (const stepId of batchStepIdsToCopy) {
+            const newEv = (0, executeBucket_js_1.batchExecutionValue)((0, utils_js_1.arrayOfLength)(totalSize, null), (0, utils_js_1.arrayOfLength)(totalSize, constants_js_1.FLAG_NULL | constants_js_1.FLAG_STOPPED));
+            store.set(stepId, newEv);
+            let offset = 0;
+            for (const plp of this.reason.parentLayerPlans) {
+                const parentBucket = sharedState._retainedBuckets.get(plp.id);
+                if (!parentBucket)
+                    continue;
+                const sourceEv = parentBucket.store.get(stepId);
+                if (sourceEv != null) {
+                    // Populate it with the values we care about
+                    for (let i = 0, l = parentBucket.size; i < l; i++) {
+                        newEv._copyResult(i + offset, sourceEv, i);
+                    }
+                }
+                offset += parentBucket.size;
+            }
         }
-        return makeNewBucketExpression(signature, reasonType, (0, tamedevil_1.default) `\
-  const itemStepId = this.rootStep.id;
-  const nullableStepStore = parentBucket.store.get(itemStepId);
-
-  const itemStepIdList = [];
-  store.set(itemStepId, ${ref_batchExecutionValue}(itemStepIdList));
-
-  // Prepare store with an empty list for each copyPlanId
-${tamedevil_1.default.join(blocks, "")}
-
-  // We'll typically be creating fewer nullableBoundary bucket entries
-  // than we have parent bucket entries (because we exclude nulls), so
-  // we must "multiply up" (down) the store entries.
-  for (
-    let originalIndex = 0;
-    originalIndex < parentBucket.size;
-    originalIndex++
-  ) {
-    const fieldValue = nullableStepStore.at(originalIndex);
-    if (fieldValue != null) {
-      const newIndex = size++;
-      map.set(originalIndex, newIndex);
-      itemStepIdList[newIndex] = fieldValue;
-
-      polymorphicPathList[newIndex] = parentBucket.polymorphicPathList[originalIndex];
-      iterators[newIndex] = parentBucket.iterators[originalIndex];
-${tamedevil_1.default.join(copyBlocks, "")}
-    }
-  }
-`);
-    }
-    else if (reasonType === "listItem") {
-        const blocks = [];
-        const copyBlocks = [];
-        for (let i = 0; i < copyCount; i++) {
-            const te_source = tamedevil_1.default.identifier(`source${i}`);
-            const te_target = tamedevil_1.default.identifier(`target${i}`);
-            const te_i = tamedevil_1.default.lit(i);
-            blocks.push((0, tamedevil_1.default) `\
-  const ${te_source} = parentBucket.store.get(copyStepIds[${te_i}]);
-  const ${te_target} = ${te_source}.isBatch ? ${ref_batchExecutionValue}([]) : ${te_source};
-  store.set(copyStepIds[${te_i}], ${te_target});
-  `);
-            copyBlocks.push((0, tamedevil_1.default) `\
-        if (${te_target}.isBatch) {
-          ${te_target}.entries[newIndex] = ${te_source}.at(originalIndex);
+        const $parentSideEffect = this.parentSideEffectStep;
+        if ($parentSideEffect) {
+            throw new Error(`Side effects were not expected at this position; this is likely an issue with your plans, but if not then please file an issue containing a minimal reproduction`);
         }
-        `);
+        ////////////////////////////////////////////////////////////////////////////
+        //
+        // Code that would be in the switch statement if we were normal...
+        //
+        for (const { targetStepId, sourceStepsByLayerPlanId } of this
+            .finalCombinations) {
+            const ev = (0, executeBucket_js_1.batchExecutionValue)((0, utils_js_1.arrayOfLength)(totalSize, null), (0, utils_js_1.arrayOfLength)(totalSize, constants_js_1.FLAG_NULL | constants_js_1.FLAG_STOPPED));
+            store.set(targetStepId, ev);
+            let offset = 0;
+            for (const plp of this.reason.parentLayerPlans) {
+                const parentBucket = sharedState._retainedBuckets.get(plp.id);
+                if (parentBucket == null)
+                    continue;
+                for (let originalIndex = 0; originalIndex < parentBucket.size; originalIndex++) {
+                    const newIndex = originalIndex + offset;
+                    if (sourceStepsByLayerPlanId[plp.id]) {
+                        for (const stepId of sourceStepsByLayerPlanId[plp.id]) {
+                            const sourceStore = parentBucket.store.get(stepId);
+                            if (!sourceStore) {
+                                const step = this.operationPlan.stepTracker.getStepById(stepId);
+                                throw new Error(`GrafastInternalError<a48ca88c-e4b9-4a4f-9a38-846fa067f143>: missing source store for ${step} (${stepId}) in ${this}`);
+                            }
+                            if ((sourceStore._flagsAt(originalIndex) & SKIP_FLAGS) == 0) {
+                                ev._copyResult(newIndex, sourceStore, originalIndex);
+                                break;
+                            }
+                        }
+                    }
+                    iterators[newIndex] = parentBucket.iterators[originalIndex];
+                }
+                offset += parentBucket.size;
+            }
         }
-        return makeNewBucketExpression(signature, reasonType, (0, tamedevil_1.default) `\
-  const listStepId = this.reason.parentStep.id;
-  const listStepStore = parentBucket.store.get(listStepId);
-
-  const itemStepIdList = [];
-  store.set(this.rootStep.id, ${ref_batchExecutionValue}(itemStepIdList));
-
-  // Prepare store with an empty list for each copyPlanId
-  ${tamedevil_1.default.join(blocks, "")}
-
-  // We'll typically be creating more listItem bucket entries than we
-  // have parent buckets, so we must "multiply up" the store entries.
-  for (
-    let originalIndex = 0;
-    originalIndex < parentBucket.size;
-    originalIndex++
-  ) {
-    const list = listStepStore.at(originalIndex);
-    if (Array.isArray(list)) {
-      const newIndexes = [];
-      map.set(originalIndex, newIndexes);
-      for (let j = 0, l = list.length; j < l; j++) {
-        const newIndex = size++;
-        newIndexes.push(newIndex);
-        itemStepIdList[newIndex] = list[j];
-
-        polymorphicPathList[newIndex] = parentBucket.polymorphicPathList[originalIndex];
-        iterators[newIndex] = parentBucket.iterators[originalIndex];
-        ${tamedevil_1.default.join(copyBlocks, "")}
-      }
-    }
-  }
-
-`);
-    }
-    else {
-        const never = reasonType;
-        return never;
-    }
-}
-function withNewBucketFactory(signature, copyCount, reasonType, callback) {
-    const fn = makeNewBucketCache.get(signature);
-    if (fn !== undefined) {
-        return callback(fn);
+        //
+        // End: code that would be in the switch statement if we were normal.
+        //
+        ////////////////////////////////////////////////////////////////////////////
+        // Reference
+        const childBucket = (0, executeBucket_js_1.newBucket)({ metaByMetaKey: undefined /* use defaults */, sharedState }, {
+            layerPlan: this,
+            size: totalSize,
+            store,
+            // PERF: not necessarily, if we don't copy the errors, we don't have the errors.
+            flagUnion,
+            polymorphicPathList,
+            polymorphicType: null,
+            iterators,
+        });
+        for (const plp of this.reason.parentLayerPlans) {
+            const parentBucket = sharedState._retainedBuckets.get(plp.id);
+            if (parentBucket != null) {
+                const map = mapByParentLayerPlanId[plp.id];
+                parentBucket.children[this.id] = {
+                    bucket: childBucket,
+                    map,
+                };
+            }
+        }
+        return childBucket;
     }
-    const building = makingNewBucketCallbacks.get(signature);
-    if (building !== undefined) {
-        building.push(callback);
-        return;
+    addCombo(sources, $target) {
+        if (this.reason.type !== "combined") {
+            throw new Error(`Combinations may only be added to combined layer plans`);
+        }
+        this.combinations.push({
+            sources: sources.map((s) => ({
+                layerPlanId: s.layerPlan.id,
+                stepId: s.step.id,
+            })),
+            targetStepId: $target.id,
+        });
+        const { layerPlansByDependentStep } = this.operationPlan.stepTracker;
+        sources.forEach(({ step }) => {
+            let set = layerPlansByDependentStep.get(step);
+            if (!set) {
+                set = new Set();
+                layerPlansByDependentStep.set(step, set);
+            }
+            set.add(this);
+        });
     }
-    const callbacks = [callback];
-    makingNewBucketCallbacks.set(signature, callbacks);
-    const executorExpression = newBucketFactoryInnerExpression(signature, copyCount, reasonType);
-    const factoryExpression = (0, tamedevil_1.default) `\
-function ${tamedevil_1.default.identifier(`layerPlanNewBucketFactory_${signature}`)}(copyStepIds) {
-  return ${executorExpression};
-}`;
-    tamedevil_1.default.runInBatch(factoryExpression, (factory) => {
-        makeNewBucketCache.set(signature, factory);
-        makingNewBucketCallbacks.delete(signature);
-        for (const callback of callbacks) {
-            callback(factory);
+    /** @internal */
+    getPartition(typeNames, polymorphicPaths) {
+        const existing = this.children.find((c) => c.reason.type === "polymorphicPartition" &&
+            // Note: it's probably okay to use arraysMatch here even though order is
+            // unimportant because probably the order of all subsets will be the
+            // same, so we don't need to do an order-independent comparison (which
+            // would be more expensiv)
+            (0, utils_js_1.arraysMatch)(c.reason.typeNames, typeNames) &&
+            (0, utils_js_1.setsMatch)(c.reason.polymorphicPaths, polymorphicPaths));
+        if (existing) {
+            return existing;
         }
-    });
+        return new LayerPlan(this.operationPlan, {
+            type: "polymorphicPartition",
+            parentLayerPlan: this,
+            typeNames,
+            polymorphicPaths,
+        });
+    }
 }
+exports.LayerPlan = LayerPlan;
 //# sourceMappingURL=LayerPlan.js.map