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

package/dist/engine/executeBucket.js

@@ -8,13 +8,15 @@ exports.unaryExecutionValue = unaryExecutionValue;
 const tslib_1 = require("tslib");
 const iterall_1 = require("iterall");
 const assert = tslib_1.__importStar(require("../assert.js"));
+const constants_js_1 = require("../constants.js");
 const dev_js_1 = require("../dev.js");
 const error_js_1 = require("../error.js");
 const inspect_js_1 = require("../inspect.js");
-const interfaces_js_1 = require("../interfaces.js");
 const timeSource_js_1 = require("../timeSource.js");
 const utils_js_1 = require("../utils.js");
-const timeoutError = Object.freeze(new error_js_1.SafeError("Execution timeout exceeded, please simplify or add limits to your request.", Object.freeze({ [interfaces_js_1.$$timeout]: true })));
+/** Default recoverable/trappable flags (excluding NULL) */
+const INHIBIT_OR_ERROR_FLAGS = constants_js_1.FLAG_INHIBITED | constants_js_1.FLAG_ERROR;
+const timeoutError = Object.freeze(new error_js_1.SafeError("Execution timeout exceeded, please simplify or add limits to your request.", Object.freeze({ [constants_js_1.$$timeout]: true })));
 function noop() {
     /*noop*/
 }
@@ -55,7 +57,7 @@ function executeBucket(bucket, requestContext) {
      */
     function reallyExecuteStepWithoutFiltering(size, step, dependencies, extra) {
         const results = executeOrStream(size, step, dependencies, extra);
-        const flags = (0, utils_js_1.arrayOfLength)(size, interfaces_js_1.NO_FLAGS);
+        const flags = (0, utils_js_1.arrayOfLength)(size, constants_js_1.NO_FLAGS);
         if ((0, utils_js_1.isPromiseLike)(results)) {
             return results.then((results) => ({ flags, results }));
         }
@@ -65,7 +67,7 @@ function executeBucket(bucket, requestContext) {
     }
     const { stopTime, eventEmitter, args } = requestContext;
     const { middleware } = args;
-    const { metaByMetaKey, size, store, layerPlan: { phases, children: childLayerPlans }, } = bucket;
+    const { metaByMetaKey, size, store, layerPlan: { phases }, } = bucket;
     const phaseCount = phases.length;
     // Like a `for(i = 0; i < phaseCount; i++)` loop with some `await`s in it, except it does promise
     // handling manually so that it can complete synchronously (no promises) if
@@ -96,11 +98,11 @@ function executeBucket(bucket, requestContext) {
                     const stepSize = step._isUnary ? 1 : bucket.size;
                     const r = timeoutError;
                     const results = (0, utils_js_1.arrayOfLength)(stepSize, r);
-                    const flags = (0, utils_js_1.arrayOfLength)(stepSize, interfaces_js_1.FLAG_ERROR);
+                    const flags = (0, utils_js_1.arrayOfLength)(stepSize, constants_js_1.FLAG_ERROR);
                     resultList[normalStepIndex] = { flags, results };
                     indexesPendingLoopOver.push(normalStepIndex);
                     // TODO: I believe we can remove this line?
-                    bucket.flagUnion |= interfaces_js_1.FLAG_ERROR;
+                    bucket.flagUnion |= constants_js_1.FLAG_ERROR;
                 }
             }
         }
@@ -130,11 +132,11 @@ function executeBucket(bucket, requestContext) {
                 catch (e) {
                     const r = e;
                     const results = (0, utils_js_1.arrayOfLength)(stepSize, r);
-                    const flags = (0, utils_js_1.arrayOfLength)(stepSize, interfaces_js_1.FLAG_ERROR);
+                    const flags = (0, utils_js_1.arrayOfLength)(stepSize, constants_js_1.FLAG_ERROR);
                     resultList[normalStepIndex] = { flags, results };
                     indexesPendingLoopOver.push(normalStepIndex);
                     // TODO: I believe we can remove this line?
-                    bucket.flagUnion |= interfaces_js_1.FLAG_ERROR;
+                    bucket.flagUnion |= constants_js_1.FLAG_ERROR;
                 }
             }
         }
@@ -184,15 +186,15 @@ function executeBucket(bucket, requestContext) {
             // hang of defers? In the mean time... Don't throw any errors here!
             const success = (finishedStep, bucket, resultIndex, value, flags) => {
                 // Fast lanes
-                if (typeof value !== "object") {
-                    // non-objects
-                    bucket.setResult(finishedStep, resultIndex, value, flags);
+                if (value == null) {
+                    // null / undefined
+                    const finalFlags = flags | constants_js_1.FLAG_NULL;
+                    bucket.setResult(finishedStep, resultIndex, value, finalFlags);
                     return;
                 }
-                else if (value === null) {
-                    // nulls
-                    const finalFlags = flags | interfaces_js_1.FLAG_NULL;
-                    bucket.setResult(finishedStep, resultIndex, null, finalFlags);
+                else if (typeof value !== "object") {
+                    // non-objects
+                    bucket.setResult(finishedStep, resultIndex, value, flags);
                     return;
                 }
                 else if ((0, error_js_1.isFlaggedValue)(value)) {
@@ -207,10 +209,47 @@ function executeBucket(bucket, requestContext) {
                     ((valueIsAsyncIterable = (0, iterall_1.isAsyncIterable)(value)) || (0, iterall_1.isIterable)(value))) {
                     // PERF: we've already calculated this once; can we reference that again here?
                     const stream = evaluateStream(bucket, finishedStep);
+                    if (!stream && !valueIsAsyncIterable && Array.isArray(value)) {
+                        // Fast mode
+                        const valueCount = value.length;
+                        /** We only create a duplicate array if the source array contains promises */
+                        let replacement = null;
+                        for (let i = 0; i < valueCount; i++) {
+                            const item = value[i];
+                            if ((0, utils_js_1.isPromiseLike)(item)) {
+                                if (replacement === null) {
+                                    // Copy up to here!
+                                    replacement = value.slice(0, i);
+                                }
+                                replacement[i] = null;
+                                const index = i;
+                                const promise = item.then((v) => void (replacement[index] = v), (e) => void (replacement[index] = (0, error_js_1.flagError)(e)));
+                                if (!promises) {
+                                    promises = [promise];
+                                }
+                                else {
+                                    promises.push(promise);
+                                }
+                            }
+                            else if (replacement !== null) {
+                                replacement[i] = item;
+                            }
+                        }
+                        const list = replacement === null ? value : replacement;
+                        bucket.setResult(finishedStep, resultIndex, list, flags);
+                        return;
+                    }
                     const initialCount = stream?.initialCount ?? Infinity;
-                    const iterator = valueIsAsyncIterable
-                        ? value[Symbol.asyncIterator]()
-                        : value[Symbol.iterator]();
+                    let iterator;
+                    try {
+                        iterator = valueIsAsyncIterable
+                            ? value[Symbol.asyncIterator]()
+                            : value[Symbol.iterator]();
+                    }
+                    catch (e) {
+                        bucket.setResult(finishedStep, resultIndex, e, flags | constants_js_1.FLAG_ERROR);
+                        return;
+                    }
                     // Here we track the iterator via the bucket, this allows us to
                     // ensure that the iterator is terminated even if the stream is never
                     // consumed (e.g. if an error is thrown/caught during execution of
@@ -222,7 +261,7 @@ function executeBucket(bucket, requestContext) {
                     if (initialCount === 0) {
                         // Optimization - defer everything
                         const arr = [];
-                        arr[interfaces_js_1.$$streamMore] = iterator;
+                        arr[constants_js_1.$$streamMore] = iterator;
                         bucket.setResult(finishedStep, resultIndex, arr, flags);
                     }
                     else {
@@ -243,19 +282,30 @@ function executeBucket(bucket, requestContext) {
                                     if (resolvedResult.done) {
                                         break;
                                     }
-                                    arr.push(await resolvedResult.value);
+                                    try {
+                                        const v = resolvedResult.value;
+                                        if ((0, utils_js_1.isPromiseLike)(v)) {
+                                            arr.push(await v);
+                                        }
+                                        else {
+                                            arr.push(v);
+                                        }
+                                    }
+                                    catch (e) {
+                                        arr.push((0, error_js_1.flagError)(e));
+                                    }
                                     if (++valuesSeen >= initialCount) {
                                         // This is safe to do in the `while` since we checked
                                         // the `0` entries condition in the optimization
                                         // above.
-                                        arr[interfaces_js_1.$$streamMore] = iterator;
+                                        arr[constants_js_1.$$streamMore] = iterator;
                                         break;
                                     }
                                 }
                                 bucket.setResult(finishedStep, resultIndex, arr, flags);
                             }
                             catch (e) {
-                                bucket.setResult(finishedStep, resultIndex, e, flags | interfaces_js_1.FLAG_ERROR);
+                                bucket.setResult(finishedStep, resultIndex, e, flags | constants_js_1.FLAG_ERROR);
                             }
                         })();
                         if (!promises) {
@@ -306,11 +356,11 @@ function executeBucket(bucket, requestContext) {
                         const { s: allStepsIndex, i: dataIndex } = pendingPromiseIndexes[i];
                         const finishedStep = _allSteps[allStepsIndex];
                         if (settledResult.status === "fulfilled") {
-                            success(finishedStep, bucket, dataIndex, settledResult.value, interfaces_js_1.NO_FLAGS);
+                            success(finishedStep, bucket, dataIndex, settledResult.value, constants_js_1.NO_FLAGS);
                         }
                         else {
                             const error = settledResult.reason;
-                            bucket.setResult(finishedStep, dataIndex, error, interfaces_js_1.FLAG_ERROR);
+                            bucket.setResult(finishedStep, dataIndex, error, constants_js_1.FLAG_ERROR);
                         }
                     }
                     return promises ? Promise.all(promises) : undefined;
@@ -318,12 +368,12 @@ function executeBucket(bucket, requestContext) {
                     .then(null, (e) => {
                     // THIS SHOULD NEVER HAPPEN!
                     console.error(`GrafastInternalError<1e9731b4-005e-4b0e-bc61-43baa62e6444>: this error should never occur! Please file an issue against grafast. Details: ${e}`);
-                    bucket.flagUnion |= interfaces_js_1.FLAG_ERROR;
+                    bucket.flagUnion |= constants_js_1.FLAG_ERROR;
                     for (let i = 0, pendingPromisesLength = pendingPromises.length; i < pendingPromisesLength; i++) {
                         const { s: allStepsIndex, i: dataIndex } = pendingPromiseIndexes[i];
                         const finishedStep = _allSteps[allStepsIndex];
                         const error = new Error(`GrafastInternalError<1e9731b4-005e-4b0e-bc61-43baa62e6444>: error occurred whilst performing completedStep(${finishedStep.id})`);
-                        bucket.setResult(finishedStep, dataIndex, error, interfaces_js_1.FLAG_ERROR);
+                        bucket.setResult(finishedStep, dataIndex, error, constants_js_1.FLAG_ERROR);
                     }
                 });
             }
@@ -379,10 +429,10 @@ function executeBucket(bucket, requestContext) {
                                 throw new Error(`GrafastInternalError<fcc8d302-ac66-40e8-aaea-ee2c7e2b30b2>: failed to get result for side effect ${$sideEffect} which impacts ${step}`);
                             }
                             const depFlags = depExecutionValue._flagsAt(dataIndex);
-                            if (depFlags & interfaces_js_1.FLAG_POLY_SKIPPED) {
+                            if (depFlags & constants_js_1.FLAG_POLY_SKIPPED) {
                                 /* noop */
                             }
-                            else if (depFlags & interfaces_js_1.FLAG_ERROR) {
+                            else if (depFlags & constants_js_1.FLAG_ERROR) {
                                 if (step._isUnary) {
                                     // COPY the unary value
                                     bucket.store.set(step.id, depExecutionValue);
@@ -401,70 +451,92 @@ function executeBucket(bucket, requestContext) {
                         const extra = extras[allStepsIndex];
                         let forceIndexValue = undefined;
                         let rejectValue = undefined;
-                        let indexFlags = interfaces_js_1.NO_FLAGS;
-                        for (let i = 0, l = step.dependencies.length; i < l; i++) {
-                            const $dep = step.dependencies[i];
-                            const forbiddenFlags = step.dependencyForbiddenFlags[i];
-                            const onReject = step.dependencyOnReject[i];
-                            const depExecutionVal = bucket.store.get($dep.id);
-                            // Search for "f2b3b1b3" for similar block
-                            const flags = depExecutionVal._flagsAt(dataIndex);
-                            const disallowedFlags = flags & forbiddenFlags;
-                            if (disallowedFlags) {
-                                indexFlags |= disallowedFlags;
-                                // If there's a reject behavior and we're FRESHLY rejected (weren't
-                                // already inhibited), use that as a fallback.
-                                // TODO: validate this.
-                                // If dep is inhibited and we don't allow inhibited, copy through (null or error).
-                                // If dep is inhibited and we do allow inhibited, but we're disallowed, use our onReject.
-                                // If dep is not inhibited, but we're disallowed, use our onReject.
-                                if (onReject !== undefined &&
-                                    (disallowedFlags & (interfaces_js_1.FLAG_INHIBITED | interfaces_js_1.FLAG_ERROR)) === interfaces_js_1.NO_FLAGS) {
-                                    rejectValue ||= onReject;
+                        let indexFlags = constants_js_1.NO_FLAGS;
+                        // Check polymorphism matches
+                        const stepPolymorphicPaths = step.polymorphicPaths;
+                        if (stepPolymorphicPaths !== null &&
+                            (step._isUnary
+                                ? /*
+                                   * already asserted that it matches;
+                                   * !! search "f4ce2c83"
+                                   */
+                                    false
+                                : /* batch check */
+                                    !stepPolymorphicPaths.has(bucket.polymorphicPathList[dataIndex]))) {
+                            indexFlags |= constants_js_1.FLAG_POLY_SKIPPED;
+                            forceIndexValue = null;
+                        }
+                        else {
+                            for (let i = 0, l = step.dependencies.length; i < l; i++) {
+                                const $dep = step.dependencies[i];
+                                const forbiddenFlags = step.dependencyForbiddenFlags[i];
+                                const onReject = step.dependencyOnReject[i];
+                                const depExecutionVal = bucket.store.get($dep.id);
+                                if (depExecutionVal === undefined) {
+                                    throw new Error(`GrafastInternalError<480e7c98-a777-4efb-b826-c339129ccff8>: could not find value in ${bucket} for ${$dep}, dependency ${i} of ${step}`);
                                 }
-                                if (forceIndexValue == null) {
-                                    if ((flags & interfaces_js_1.FLAG_ERROR) !== 0) {
-                                        const v = depExecutionVal.at(dataIndex);
-                                        forceIndexValue = v;
+                                // Search for "f2b3b1b3" for similar block
+                                const flags = depExecutionVal._flagsAt(dataIndex);
+                                const disallowedFlags = flags & forbiddenFlags;
+                                if (disallowedFlags) {
+                                    indexFlags |= disallowedFlags;
+                                    // If there's a reject behavior and we're FRESHLY rejected (weren't
+                                    // already inhibited), use that as a fallback.
+                                    // TODO: validate this.
+                                    // If dep is inhibited and we don't allow inhibited, copy through (null or error).
+                                    // If dep is inhibited and we do allow inhibited, but we're disallowed, use our onReject.
+                                    // If dep is not inhibited, but we're disallowed, use our onReject.
+                                    if (onReject !== undefined &&
+                                        (disallowedFlags & INHIBIT_OR_ERROR_FLAGS) === constants_js_1.NO_FLAGS) {
+                                        rejectValue ||= onReject;
+                                    }
+                                    if (forceIndexValue == null) {
+                                        if ((flags & constants_js_1.FLAG_ERROR) !== constants_js_1.NO_FLAGS) {
+                                            const v = depExecutionVal.at(dataIndex);
+                                            forceIndexValue = v;
+                                        }
+                                        else {
+                                            forceIndexValue = null;
+                                        }
                                     }
                                     else {
-                                        forceIndexValue = null;
+                                        // First error wins, ignore this second error.
                                     }
+                                    // End "f2b3b1b3" block
                                 }
-                                else {
-                                    // First error wins, ignore this second error.
-                                }
-                                // End "f2b3b1b3" block
-                            }
-                            else if (forceIndexValue === undefined) {
-                                const depVal = depExecutionVal.at(dataIndex);
-                                let depFlags;
-                                if ((bucket.flagUnion & interfaces_js_1.FLAG_ERROR) === interfaces_js_1.FLAG_ERROR &&
-                                    ((depFlags = depExecutionVal._flagsAt(dataIndex)) &
-                                        interfaces_js_1.FLAG_ERROR) ===
-                                        interfaces_js_1.FLAG_ERROR) {
-                                    if (step._isUnary) {
-                                        // COPY the unary value
-                                        bucket.store.set(step.id, depExecutionVal);
-                                        bucket.flagUnion |= depFlags;
-                                    }
-                                    else {
-                                        bucket.setResult(step, dataIndex, depVal, interfaces_js_1.FLAG_ERROR);
+                                else if (forceIndexValue === undefined) {
+                                    const depVal = depExecutionVal.at(dataIndex);
+                                    let depFlags;
+                                    if ((bucket.flagUnion & constants_js_1.FLAG_ERROR) === constants_js_1.FLAG_ERROR &&
+                                        ((depFlags = depExecutionVal._flagsAt(dataIndex)) &
+                                            constants_js_1.FLAG_ERROR) ===
+                                            constants_js_1.FLAG_ERROR) {
+                                        if (step._isUnary) {
+                                            // COPY the unary value
+                                            bucket.store.set(step.id, depExecutionVal);
+                                            bucket.flagUnion |= depFlags;
+                                        }
+                                        else {
+                                            bucket.setResult(step, dataIndex, depVal, constants_js_1.FLAG_ERROR);
+                                        }
+                                        continue stepLoop;
                                     }
-                                    continue stepLoop;
+                                    deps.push(depVal);
                                 }
-                                deps.push(depVal);
                             }
                         }
                         let stepResult, stepFlags;
                         if (forceIndexValue !== undefined) {
                             // Search for "17217999b7a7" for similar block
-                            if (forceIndexValue == null && rejectValue != null) {
-                                indexFlags |= interfaces_js_1.FLAG_ERROR;
+                            if ((indexFlags & constants_js_1.FLAG_POLY_SKIPPED) === constants_js_1.FLAG_POLY_SKIPPED) {
+                                // Already skipped
+                            }
+                            else if (forceIndexValue == null && rejectValue != null) {
+                                indexFlags |= constants_js_1.FLAG_ERROR;
                                 forceIndexValue = rejectValue;
                             }
                             else {
-                                indexFlags |= interfaces_js_1.FLAG_INHIBITED;
+                                indexFlags |= constants_js_1.FLAG_INHIBITED;
                             }
                             // End "17217999b7a7" block
                             stepResult = forceIndexValue;
@@ -480,7 +552,7 @@ function executeBucket(bucket, requestContext) {
                             }
                             else {
                                 stepResult = rawStepResult;
-                                stepFlags = rawStepResult == null ? interfaces_js_1.FLAG_NULL : interfaces_js_1.NO_FLAGS;
+                                stepFlags = rawStepResult == null ? constants_js_1.FLAG_NULL : constants_js_1.NO_FLAGS;
                             }
                         }
                         // TODO: what if stepResult is _returned_ error (as opposed to
@@ -492,7 +564,7 @@ function executeBucket(bucket, requestContext) {
                         bucket.setResult(step, dataIndex, stepResult, stepFlags);
                     }
                     catch (e) {
-                        bucket.setResult(step, dataIndex, e, interfaces_js_1.FLAG_ERROR);
+                        bucket.setResult(step, dataIndex, e, constants_js_1.FLAG_ERROR);
                     }
                 }
             }
@@ -539,11 +611,13 @@ function executeBucket(bucket, requestContext) {
     }
     // Function definitions below here
     function executeOrStream(count, step, values, extra) {
-        if (dev_js_1.isDev && step._isUnary && count !== 1) {
-            throw new Error(`GrafastInternalError<84a6cdfa-e8fe-4dea-85fe-9426a6a78027>: ${step} is a unary step, but we're attempting to pass it ${count} (!= 1) values`);
-        }
-        if (step.execute.length > 1) {
-            throw new Error(`${step} is using a legacy form of 'execute' which accepts multiple arguments, please see https://err.red/gev2`);
+        if (dev_js_1.isDev) {
+            if (step._isUnary && count !== 1) {
+                throw new Error(`GrafastInternalError<84a6cdfa-e8fe-4dea-85fe-9426a6a78027>: ${step} is a unary step, but we're attempting to pass it ${count} (!= 1) values`);
+            }
+            if (step.execute.length > 1) {
+                throw new Error(`${step} is using a legacy form of 'execute' which accepts multiple arguments, please see https://err.red/gev2`);
+            }
         }
         const executeDetails = {
             indexMap: makeIndexMap(count),
@@ -579,6 +653,7 @@ function executeBucket(bucket, requestContext) {
         let needsTransform = false;
         /** If all we see is errors, there's no need to execute! */
         let newSize = 0;
+        const newPolymorphicPathList = [];
         let stepPolymorphicPaths = step.polymorphicPaths;
         const legitDepsCount = (0, utils_js_1.sudo)(step).dependencies.length;
         const dependenciesIncludingSideEffectsCount = dependenciesIncludingSideEffects.length;
@@ -604,14 +679,14 @@ function executeBucket(bucket, requestContext) {
                 : null;
             let rejectValue = undefined;
             let indexFlags = hasPolyMatch
-                ? interfaces_js_1.NO_FLAGS
-                : interfaces_js_1.FLAG_POLY_SKIPPED;
+                ? constants_js_1.NO_FLAGS
+                : constants_js_1.FLAG_POLY_SKIPPED;
             if (stepPolymorphicPaths !== null &&
                 !stepPolymorphicPaths.has(polymorphicPathList[dataIndex])) {
-                indexFlags |= interfaces_js_1.FLAG_POLY_SKIPPED;
+                indexFlags |= constants_js_1.FLAG_POLY_SKIPPED;
                 forceIndexValue = null;
             }
-            else if (extra._bucket.flagUnion) {
+            else if (extra._bucket.flagUnion !== 0) {
                 for (let i = 0; i < dependenciesIncludingSideEffectsCount; i++) {
                     const depExecutionVal = dependenciesIncludingSideEffects[i];
                     const forbiddenFlags = dependencyForbiddenFlags[i];
@@ -628,11 +703,11 @@ function executeBucket(bucket, requestContext) {
                         // If dep is inhibited and we do allow inhibited, but we're disallowed, use our onReject.
                         // If dep is not inhibited, but we're disallowed, use our onReject.
                         if (onReject !== undefined &&
-                            (disallowedFlags & (interfaces_js_1.FLAG_INHIBITED | interfaces_js_1.FLAG_ERROR)) === interfaces_js_1.NO_FLAGS) {
+                            (disallowedFlags & (constants_js_1.FLAG_INHIBITED | constants_js_1.FLAG_ERROR)) === constants_js_1.NO_FLAGS) {
                             rejectValue ||= onReject;
                         }
                         if (forceIndexValue == null) {
-                            if ((flags & interfaces_js_1.FLAG_ERROR) !== 0) {
+                            if ((flags & constants_js_1.FLAG_ERROR) !== 0) {
                                 const v = depExecutionVal.at(dataIndex);
                                 forceIndexValue = v;
                             }
@@ -664,18 +739,19 @@ function executeBucket(bucket, requestContext) {
                 }
                 // Search for "17217999b7a7" for similar block
                 if (forceIndexValue == null && rejectValue != null) {
-                    indexFlags |= interfaces_js_1.FLAG_ERROR;
+                    indexFlags |= constants_js_1.FLAG_ERROR;
                     forceIndexValue = rejectValue;
                 }
                 else {
-                    indexFlags |= interfaces_js_1.FLAG_INHIBITED;
+                    indexFlags |= constants_js_1.FLAG_INHIBITED;
                 }
                 // End "17217999b7a7" block
                 forcedValues.flags[dataIndex] = indexFlags;
                 forcedValues.results[dataIndex] = forceIndexValue;
             }
             else {
-                newSize++;
+                const newIndex = newSize++;
+                newPolymorphicPathList[newIndex] = polymorphicPathList[dataIndex];
                 if (needsTransform) {
                     // dependenciesWithoutErrors has limited content; add this non-error value
                     for (let depListIndex = 0; depListIndex < legitDepsCount; depListIndex++) {
@@ -763,16 +839,12 @@ function executeBucket(bucket, requestContext) {
                 }
             }
             if (dev_js_1.isDev &&
-                step.layerPlan.reason.type === "polymorphic" &&
+                (step.layerPlan.reason.type === "polymorphic" ||
+                    step.layerPlan.reason.type === "polymorphicPartition") &&
                 step.polymorphicPaths === null) {
                 throw new Error(`GrafastInternalError<c33328fe-6758-4699-8ac6-7be41ce58bfb>: a step without polymorphic paths cannot belong to a polymorphic bucket`);
             }
-            if (!needsFiltering) {
-                const isSelectiveStep = step.layerPlan.reason.type === "polymorphic" &&
-                    step.polymorphicPaths.size !==
-                        step.layerPlan.reason.polymorphicPaths.size;
-                needsFiltering ||= isSelectiveStep;
-            }
+            needsFiltering ||= step._isSelectiveStep;
             const result = needsFiltering
                 ? reallyExecuteStepWithFiltering(step, dependencies, _rawForbiddenFlags, _rawOnReject, bucket.polymorphicPathList, extra)
                 : reallyExecuteStepWithoutFiltering(size, step, $sideEffect ? dependencies.slice(0, depCount) : dependencies, extra);
@@ -782,7 +854,7 @@ function executeBucket(bucket, requestContext) {
                     // ExecutionValue is created:
                     //   bucket.hasNonZeroStatus = true;
                     return {
-                        flags: (0, utils_js_1.arrayOfLength)(size, interfaces_js_1.FLAG_ERROR | interfaces_js_1.FLAG_STOPPED),
+                        flags: (0, utils_js_1.arrayOfLength)(size, constants_js_1.FLAG_ERROR | constants_js_1.FLAG_STOPPED),
                         results: (0, utils_js_1.arrayOfLength)(size, error),
                     };
                 });
@@ -796,84 +868,167 @@ function executeBucket(bucket, requestContext) {
             // ExecutionValue is created:
             //   bucket.hasNonZeroStatus = true;
             return {
-                flags: (0, utils_js_1.arrayOfLength)(size, interfaces_js_1.FLAG_ERROR | interfaces_js_1.FLAG_STOPPED),
+                flags: (0, utils_js_1.arrayOfLength)(size, constants_js_1.FLAG_ERROR | constants_js_1.FLAG_STOPPED),
                 results: (0, utils_js_1.arrayOfLength)(size, error),
             };
         }
     }
     function executeSamePhaseChildren() {
-        // PERF: create a JIT factory for this at planning time
-        const childPromises = [];
-        // This promise should never reject
-        let mutationQueue = null;
-        /**
-         * Ensures that callback is only called once all other enqueued callbacks
-         * are called.
-         */
-        const enqueue = (callback) => {
-            const result = mutationQueue ? mutationQueue.then(callback) : callback();
-            if ((0, utils_js_1.isPromiseLike)(result)) {
-                mutationQueue = result.then(noop, noop);
+        const result = completeBucketAndExecuteSamePhaseChildren(bucket, requestContext);
+        if (result != null) {
+            return result.then(() => {
+                // PERF: this seems like a bad idea! We're forcing the bucket to be
+                // retained in this closure? Why?
+                bucket.isComplete = true;
+                return;
+            });
+        }
+        else {
+            bucket.isComplete = true;
+            return;
+        }
+    }
+}
+function completeBucketAndExecuteSamePhaseChildren(bucket, requestContext) {
+    const { layerPlan, sharedState } = bucket;
+    const result = markLayerPlanAsDone(requestContext, sharedState, layerPlan, bucket);
+    bucket.sharedState.release(bucket);
+    return result;
+}
+function markLayerPlanAsDone(requestContext, sharedState, layerPlan, bucket) {
+    if (sharedState._doneBucketIds.has(layerPlan.id)) {
+        throw new Error(`${bucket} has already completed, it cannot complete again!`);
+    }
+    sharedState._doneBucketIds.add(layerPlan.id);
+    const childPromises = [];
+    // This promise should never reject
+    let mutationQueue = null;
+    /**
+     * Ensures that callback is only called once all other enqueued callbacks
+     * are called.
+     */
+    const enqueue = (callback) => {
+        const result = mutationQueue ? mutationQueue.then(callback) : callback();
+        if ((0, utils_js_1.isPromiseLike)(result)) {
+            mutationQueue = result.then(noop, noop);
+        }
+        return result;
+    };
+    const { children: childLayerPlans } = layerPlan;
+    // PERF: create a JIT factory for this at planning time
+    loop: for (const childLayerPlan of childLayerPlans) {
+        switch (childLayerPlan.reason.type) {
+            case "nullableBoundary":
+            case "listItem":
+            case "polymorphic":
+            case "polymorphicPartition": {
+                const childBucket = bucket == null ? null : childLayerPlan.newBucket(bucket);
+                // Execute
+                const result = childBucket !== null
+                    ? executeBucket(childBucket, requestContext)
+                    : markLayerPlanAsDone(requestContext, sharedState, childLayerPlan, null);
+                if ((0, utils_js_1.isPromiseLike)(result)) {
+                    childPromises.push(result);
+                }
+                break;
             }
-            return result;
-        };
-        loop: for (const childLayerPlan of childLayerPlans) {
-            switch (childLayerPlan.reason.type) {
-                case "nullableBoundary":
-                case "listItem":
-                case "polymorphic": {
-                    const childBucket = childLayerPlan.newBucket(bucket);
-                    if (childBucket !== null) {
-                        // Execute
-                        const result = executeBucket(childBucket, requestContext);
-                        if ((0, utils_js_1.isPromiseLike)(result)) {
-                            childPromises.push(result);
-                        }
-                    }
-                    break;
+            case "mutationField": {
+                const childBucket = bucket == null ? null : childLayerPlan.newBucket(bucket);
+                // Enqueue for execution (mutations must run in order)
+                const promise = enqueue(() => childBucket !== null
+                    ? executeBucket(childBucket, requestContext)
+                    : markLayerPlanAsDone(requestContext, sharedState, childLayerPlan, null));
+                if ((0, utils_js_1.isPromiseLike)(promise)) {
+                    childPromises.push(promise);
                 }
-                case "mutationField": {
-                    const childBucket = childLayerPlan.newBucket(bucket);
-                    if (childBucket !== null) {
-                        // Enqueue for execution (mutations must run in order)
-                        const promise = enqueue(() => executeBucket(childBucket, requestContext));
-                        if ((0, utils_js_1.isPromiseLike)(promise)) {
-                            childPromises.push(promise);
-                        }
+                break;
+            }
+            case "combined": {
+                // First, see if _all_ parent layer plans are ready
+                let allParentLayerPlansAreReady = true;
+                for (const lp of childLayerPlan.reason.parentLayerPlans) {
+                    if (lp === layerPlan)
+                        continue;
+                    if (!sharedState._doneBucketIds.has(lp.id)) {
+                        allParentLayerPlansAreReady = false;
+                        break;
                     }
-                    break;
                 }
-                case "subroutine":
-                case "subscription":
-                case "defer": {
-                    // Ignore; these are handled elsewhere
+                if (!allParentLayerPlansAreReady) {
+                    // The last parent layer plan to complete will handle it.
+                    // Make sure we're retained so it can use our data!
+                    // Will be released inside the "combined" branch in childLayerPlan.newBucket
+                    if (bucket != null) {
+                        bucket.sharedState.retain(bucket);
+                    }
+                    // TODO: MAKE SURE CANCELLED BUCKETS ARE HANDLED!
                     continue loop;
                 }
-                case "root": {
-                    throw new Error(
-                    // *confused emoji*
-                    "GrafastInternalError<05fb7069-81b5-43f7-ae71-f62547d2c2b7>: root cannot be not the root (...)");
-                }
-                default: {
-                    const never = childLayerPlan.reason;
-                    throw new Error(`GrafastInternalError<c6984a96-050e-4d40-ab18-a8c5dc7e239b>: unhandled reason '${(0, inspect_js_1.inspect)(never)}'`);
+                const childBucket = childLayerPlan.newCombinedBucket({ sharedState });
+                if (childBucket !== null) {
+                    // Execute
+                    const result = executeBucket(childBucket, requestContext);
+                    if ((0, utils_js_1.isPromiseLike)(result)) {
+                        childPromises.push(result);
+                    }
                 }
+                break;
+            }
+            case "subroutine":
+            case "subscription":
+            case "defer": {
+                // Ignore; these are handled elsewhere
+                continue loop;
+            }
+            case "root": {
+                throw new Error(
+                // *confused emoji*
+                "GrafastInternalError<05fb7069-81b5-43f7-ae71-f62547d2c2b7>: root cannot be not the root (...)");
+            }
+            default: {
+                const never = childLayerPlan.reason;
+                throw new Error(`GrafastInternalError<c6984a96-050e-4d40-ab18-a8c5dc7e239b>: unhandled reason '${(0, inspect_js_1.inspect)(never)}'`);
             }
-        }
-        if (childPromises.length > 0) {
-            return Promise.all(childPromises).then(() => {
-                bucket.isComplete = true;
-                return;
-            });
-        }
-        else {
-            bucket.isComplete = true;
-            return;
         }
     }
+    if (childPromises.length > 0) {
+        // These should never reject; rejections will bubble up through the promise chain
+        return Promise.all(childPromises).then(noop);
+    }
+    else {
+        return;
+    }
+}
+function makeSharedState(layerPlan) {
+    // This is from a stream/defer/similar.
+    // There might be combined layer plans in it.
+    // These combined layer plans might reference other layer plans which will
+    // never execute (they're outside of our tree).
+    // We should mark these other layer plans as "done".
+    const _doneBucketIds = new Set(layerPlan.outOfBoundsLayerPlanIds);
+    return {
+        _doneBucketIds,
+        _retainedBuckets: new Map(),
+        retain(bucket) {
+            this._retainedBuckets.set(bucket.layerPlan.id, bucket);
+            bucket.retainCount++;
+        },
+        release(bucket) {
+            bucket.retainCount--;
+            if (bucket.retainCount <= 0) {
+                this._retainedBuckets.delete(bucket.layerPlan.id);
+            }
+        },
+    };
 }
 /** @internal */
-function newBucket(spec, parentMetaByMetaKey) {
+function newBucket(parent, spec) {
+    const parentMetaByMetaKey = parent?.metaByMetaKey;
+    const sharedState = 
+    // Do not copy state across phase transitions
+    (0, utils_js_1.isPhaseTransitionLayerPlan)(spec.layerPlan)
+        ? makeSharedState(spec.layerPlan)
+        : (parent?.sharedState ?? makeSharedState(spec.layerPlan));
     if (dev_js_1.isDev) {
         // Some validations
         if (!(spec.size > 0)) {
@@ -901,7 +1056,7 @@ function newBucket(spec, parentMetaByMetaKey) {
         }
     }
     const type = spec.layerPlan.reason.type;
-    const metaByMetaKey = parentMetaByMetaKey === null ||
+    const metaByMetaKey = parentMetaByMetaKey == null ||
         type === "root" ||
         type === "mutationField" ||
         type === "subscription"
@@ -909,15 +1064,18 @@ function newBucket(spec, parentMetaByMetaKey) {
             spec.layerPlan.operationPlan.makeMetaByMetaKey()
         : parentMetaByMetaKey;
     // Copy from spec
-    const { layerPlan, store, size, flagUnion, polymorphicPathList, iterators } = spec;
+    const { layerPlan, store, size, flagUnion, polymorphicPathList, polymorphicType, iterators, } = spec;
     const children = Object.create(null);
-    return {
+    const bucket = {
+        sharedState,
+        retainCount: 0,
         toString: bucketToString,
         layerPlan,
         store,
         size,
         flagUnion,
         polymorphicPathList,
+        polymorphicType,
         iterators,
         metaByMetaKey,
         isComplete: false,
@@ -956,6 +1114,9 @@ function newBucket(spec, parentMetaByMetaKey) {
             }
         },
     };
+    // Will be released when setDone is called
+    sharedState.retain(bucket);
+    return bucket;
 }
 function bucketToString() {
     return `Bucket<${this.layerPlan}>`;
@@ -1003,7 +1164,7 @@ function batchThrowNotUnary() {
 }
 function batchGetStateUnion() {
     if (this._cachedStateUnion === null) {
-        let u = interfaces_js_1.NO_FLAGS;
+        let u = constants_js_1.NO_FLAGS;
         for (const flag of this._flags) {
             u = u | flag;
         }