grafast 0.1.1-beta.2 → 0.1.1-beta.21

package/dist/engine/executeBucket.js

@@ -1,6 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.newBucket = exports.executeBucket = void 0;
+exports.executeBucket = executeBucket;
+exports.newBucket = newBucket;
+exports.bucketToString = bucketToString;
+exports.batchExecutionValue = batchExecutionValue;
+exports.unaryExecutionValue = unaryExecutionValue;
 const tslib_1 = require("tslib");
 const iterall_1 = require("iterall");
 const assert = tslib_1.__importStar(require("../assert.js"));
@@ -8,17 +12,8 @@ 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 step_js_1 = require("../step.js");
 const timeSource_js_1 = require("../timeSource.js");
 const utils_js_1 = require("../utils.js");
-const DEBUG_POLYMORPHISM = false;
-/** Path to use when there's no polymorphic paths. */
-const NO_POLY_PATH = "";
-// TODO: the handling of polymorphism via POLY_SKIPPED is distasteful. Find a
-// better approach.
-// An error that indicates this entry was skipped because it didn't match
-// polymorphicPath.
-const POLY_SKIPPED = (0, error_js_1.newGrafastError)(new Error("GrafastInternalError<757b99f9-cb4d-4141-895d-8c687b2048fd>: Polymorphic skipped; you should never see this"), null);
 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 })));
 function noop() {
     /*noop*/
@@ -33,31 +28,45 @@ function noop() {
  *
  * @internal
  */
-function mergeErrorsBackIn(results, errors, resultCount) {
+function mergeErrorsBackIn(results, forcedValues, resultCount) {
+    const finalFlags = [];
     const finalResults = [];
+    /** The index within `results`, which is shorter than `resultCount` */
     let resultIndex = 0;
-    for (let i = 0; i < resultCount; i++) {
-        const error = errors[i];
-        if (error !== undefined) {
-            finalResults[i] = error;
+    for (let finalIndex = 0; finalIndex < resultCount; finalIndex++) {
+        const flags = forcedValues.flags[finalIndex];
+        if (flags !== undefined) {
+            const value = forcedValues.results[finalIndex];
+            finalResults[finalIndex] = value;
+            finalFlags[finalIndex] = flags;
         }
         else {
-            finalResults[i] = results[resultIndex++];
+            finalResults[finalIndex] = results[resultIndex++];
+            finalFlags[finalIndex] = 0;
         }
     }
-    return finalResults;
+    return { flags: finalFlags, results: finalResults };
 }
 /** @internal */
 function executeBucket(bucket, requestContext) {
     /**
      * Execute the step directly; since there's no errors we can pass the
-     * dependencies through verbatim!
+     * dependencies through verbatim.
      */
-    const reallyExecuteStepWithNoErrors = executeOrStream;
-    const { stopTime, eventEmitter } = 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);
+        if ((0, utils_js_1.isPromiseLike)(results)) {
+            return results.then((results) => ({ flags, results }));
+        }
+        else {
+            return { flags, results };
+        }
+    }
+    const { stopTime, eventEmitter, args } = requestContext;
+    const { middleware } = args;
     const { metaByMetaKey, size, store, layerPlan: { phases, children: childLayerPlans }, } = bucket;
     const phaseCount = phases.length;
-    let sideEffectStepsWithErrors = null;
     // 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
     // possible.
@@ -74,9 +83,8 @@ function executeBucket(bucket, requestContext) {
          */
         let indexesPendingLoopOver = [];
         let executePromises = null;
-        let sideEffectSteps = null;
         let executePromiseResultIndex = null;
-        const results = [];
+        const resultList = [];
         if (phase.checkTimeout &&
             stopTime !== null &&
             timeSource_js_1.timeSource.now() >= stopTime) {
@@ -85,11 +93,14 @@ function executeBucket(bucket, requestContext) {
                 const normalSteps = phase.normalSteps;
                 for (let normalStepIndex = 0, l = normalSteps.length; normalStepIndex < l; normalStepIndex++) {
                     const step = normalSteps[normalStepIndex].step;
-                    const r = (0, error_js_1.newGrafastError)(timeoutError, step.id);
-                    const result = (0, utils_js_1.arrayOfLength)(bucket.size, r);
-                    results[normalStepIndex] = result;
+                    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);
+                    resultList[normalStepIndex] = { flags, results };
                     indexesPendingLoopOver.push(normalStepIndex);
-                    bucket.hasErrors = true;
+                    // TODO: I believe we can remove this line?
+                    bucket.flagUnion |= interfaces_js_1.FLAG_ERROR;
                 }
             }
         }
@@ -97,18 +108,11 @@ function executeBucket(bucket, requestContext) {
             const normalSteps = phase.normalSteps;
             for (let normalStepIndex = 0, l = normalSteps.length; normalStepIndex < l; normalStepIndex++) {
                 const step = normalSteps[normalStepIndex].step;
-                if (step.hasSideEffects) {
-                    if (sideEffectSteps === null) {
-                        sideEffectSteps = [step];
-                    }
-                    else {
-                        sideEffectSteps.push(step);
-                    }
-                }
+                const stepSize = step._isUnary ? 1 : bucket.size;
                 try {
                     const r = executeStep(step);
                     if ((0, utils_js_1.isPromiseLike)(r)) {
-                        results[normalStepIndex] = undefined /* will populate shortly */;
+                        resultList[normalStepIndex] = undefined /* will populate shortly */;
                         if (!executePromises) {
                             executePromises = [r];
                             executePromiseResultIndex = [normalStepIndex];
@@ -119,37 +123,21 @@ function executeBucket(bucket, requestContext) {
                         }
                     }
                     else {
-                        results[normalStepIndex] = r;
+                        resultList[normalStepIndex] = r;
                         indexesPendingLoopOver.push(normalStepIndex);
                     }
                 }
                 catch (e) {
-                    const r = (0, error_js_1.newGrafastError)(e, step.id);
-                    const result = (0, utils_js_1.arrayOfLength)(bucket.size, r);
-                    results[normalStepIndex] = result;
+                    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);
+                    resultList[normalStepIndex] = { flags, results };
                     indexesPendingLoopOver.push(normalStepIndex);
-                    bucket.hasErrors = true;
+                    // TODO: I believe we can remove this line?
+                    bucket.flagUnion |= interfaces_js_1.FLAG_ERROR;
                 }
             }
         }
-        const handleSideEffectSteps = () => {
-            if (!sideEffectStepsWithErrors) {
-                sideEffectStepsWithErrors = bucket.polymorphicPathList.reduce((memo, path) => {
-                    memo[path ?? NO_POLY_PATH] = [];
-                    return memo;
-                }, Object.create(null));
-            }
-            for (const step of sideEffectSteps) {
-                if (step.polymorphicPaths) {
-                    for (const path of step.polymorphicPaths) {
-                        sideEffectStepsWithErrors[path].push(step);
-                    }
-                }
-                else {
-                    sideEffectStepsWithErrors[NO_POLY_PATH].push(step);
-                }
-            }
-        };
         const next = () => {
             return nextPhase(phaseIndex + 1);
         };
@@ -164,16 +152,26 @@ function executeBucket(bucket, requestContext) {
             indexesPendingLoopOver = [];
             // Validate executed steps
             for (const allStepsIndex of indexesToProcess) {
-                const result = results[allStepsIndex];
                 const finishedStep = _allSteps[allStepsIndex];
-                const resultLength = result?.length;
-                if (resultLength !== size) {
-                    if (!Array.isArray(result)) {
-                        throw new Error(`Result from ${finishedStep} should be an array, instead received ${(0, inspect_js_1.inspect)(result, { colors: true })}`);
+                const internalResult = resultList[allStepsIndex];
+                if (!internalResult) {
+                    throw new Error(`GrafastInternalError<166ef53d-b80d-4bea-8b54-803c2694112a>: Result from ${finishedStep} should exist`);
+                }
+                const { /* flags, */ results } = internalResult;
+                const resultLength = results?.length;
+                const expectedSize = finishedStep._isUnary ? 1 : size;
+                if (resultLength !== expectedSize) {
+                    if (!Array.isArray(results)) {
+                        throw new Error(`Result from ${finishedStep} should be an array, instead received ${(0, inspect_js_1.inspect)(results, { colors: true })}`);
                     }
-                    throw new Error(`Result array from ${finishedStep} should have length ${size}, instead it had length ${result.length}`);
+                    throw new Error(`Result array from ${finishedStep} should have length ${expectedSize}${finishedStep._isUnary ? " (because it's unary)" : ""}, instead it had length ${results.length}`);
+                }
+                if (finishedStep._isUnary) {
+                    // Handled later
+                }
+                else {
+                    bucket.store.set(finishedStep.id, batchExecutionValue((0, utils_js_1.arrayOfLength)(size)));
                 }
-                bucket.store.set(finishedStep.id, (0, utils_js_1.arrayOfLength)(size));
             }
             // Need to complete promises, check for errors, etc.
             // **DO NOT THROW, DO NOT ALLOW AN ERROR TO BE RAISED!**
@@ -182,25 +180,34 @@ function executeBucket(bucket, requestContext) {
             let promises;
             let pendingPromises;
             let pendingPromiseIndexes;
-            const success = (finishedStep, finalResult, resultIndex, value) => {
-                let proto;
-                if (
-                // Fast-lane for non-objects
-                typeof value !== "object" ||
-                    value === null) {
-                    finalResult[resultIndex] = value;
+            // TODO: it seems that if this throws an error it results in a permanent
+            // 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);
+                    return;
+                }
+                else if (value === null) {
+                    // nulls
+                    const finalFlags = flags | interfaces_js_1.FLAG_NULL;
+                    bucket.setResult(finishedStep, resultIndex, null, finalFlags);
+                    return;
+                }
+                else if ((0, error_js_1.isFlaggedValue)(value)) {
+                    // flagged values
+                    const finalFlags = flags | value.flags;
+                    bucket.setResult(finishedStep, resultIndex, value.value, finalFlags);
                     return;
                 }
                 let valueIsAsyncIterable;
-                if (
-                // Are we streaming this? If so, we need an iterable or async
-                // iterable.
-                finishedStep._stepOptions.stream &&
+                if (finishedStep._stepOptions.walkIterable &&
+                    // PERF: do we want to handle arrays differently?
                     ((valueIsAsyncIterable = (0, iterall_1.isAsyncIterable)(value)) || (0, iterall_1.isIterable)(value))) {
-                    const streamOptions = finishedStep._stepOptions.stream;
-                    const initialCount = streamOptions
-                        ? streamOptions.initialCount
-                        : Infinity;
+                    // PERF: we've already calculated this once; can we reference that again here?
+                    const stream = evaluateStream(bucket, finishedStep);
+                    const initialCount = stream?.initialCount ?? Infinity;
                     const iterator = valueIsAsyncIterable
                         ? value[Symbol.asyncIterator]()
                         : value[Symbol.iterator]();
@@ -216,7 +223,7 @@ function executeBucket(bucket, requestContext) {
                         // Optimization - defer everything
                         const arr = [];
                         arr[interfaces_js_1.$$streamMore] = iterator;
-                        finalResult[resultIndex] = arr;
+                        bucket.setResult(finishedStep, resultIndex, arr, flags);
                     }
                     else {
                         // Evaluate the first initialCount entries, rest is streamed.
@@ -232,11 +239,11 @@ function executeBucket(bucket, requestContext) {
                                  */
                                 let resultPromise;
                                 while ((resultPromise = iterator.next())) {
-                                    const finalResult = await resultPromise;
-                                    if (finalResult.done) {
+                                    const resolvedResult = await resultPromise;
+                                    if (resolvedResult.done) {
                                         break;
                                     }
-                                    arr.push(await finalResult.value);
+                                    arr.push(await resolvedResult.value);
                                     if (++valuesSeen >= initialCount) {
                                         // This is safe to do in the `while` since we checked
                                         // the `0` entries condition in the optimization
@@ -245,11 +252,10 @@ function executeBucket(bucket, requestContext) {
                                         break;
                                     }
                                 }
-                                finalResult[resultIndex] = arr;
+                                bucket.setResult(finishedStep, resultIndex, arr, flags);
                             }
                             catch (e) {
-                                bucket.hasErrors = true;
-                                finalResult[resultIndex] = (0, error_js_1.newGrafastError)(e, finishedStep.id);
+                                bucket.setResult(finishedStep, resultIndex, e, flags | interfaces_js_1.FLAG_ERROR);
                             }
                         })();
                         if (!promises) {
@@ -260,27 +266,25 @@ function executeBucket(bucket, requestContext) {
                         }
                     }
                 }
-                else if ((proto = Object.getPrototypeOf(value)) === null ||
-                    proto === Object.prototype) {
-                    finalResult[resultIndex] = value;
-                }
-                else if (value instanceof Error) {
-                    const e = error_js_1.$$error in value ? value : (0, error_js_1.newGrafastError)(value, finishedStep.id);
-                    finalResult[resultIndex] = e;
-                    bucket.hasErrors = true;
-                }
                 else {
-                    finalResult[resultIndex] = value;
+                    bucket.setResult(finishedStep, resultIndex, value, flags);
                 }
             };
             for (const allStepsIndex of indexesToProcess) {
                 const step = _allSteps[allStepsIndex];
-                const result = results[allStepsIndex];
-                const storeEntry = bucket.store.get(step.id);
-                for (let dataIndex = 0; dataIndex < size; dataIndex++) {
-                    const val = result[dataIndex];
+                const internalResult = resultList[allStepsIndex];
+                if (!internalResult) {
+                    throw new Error(`GrafastInternalError<b82038d6-ca4e-4b55-8ed4-4d7c879f5dc2>: Result from ${step} should exist`);
+                }
+                const { flags, results } = internalResult;
+                const count = step._isUnary ? 1 : size;
+                for (let dataIndex = 0; dataIndex < count; dataIndex++) {
+                    const val = results[dataIndex];
                     if (step.isSyncAndSafe || !(0, utils_js_1.isPromiseLike)(val)) {
-                        success(step, storeEntry, dataIndex, val);
+                        if (flags[dataIndex] == null) {
+                            throw new Error(`GraphileInternalError<75df71bb-0f76-4a98-9664-9167d502296a>: result for ${step} has no flag at index ${dataIndex} (value = ${(0, inspect_js_1.inspect)(val)})`);
+                        }
+                        success(step, bucket, dataIndex, val, flags[dataIndex]);
                     }
                     else {
                         if (!pendingPromises) {
@@ -301,41 +305,34 @@ function executeBucket(bucket, requestContext) {
                         const settledResult = resultSettledResult[i];
                         const { s: allStepsIndex, i: dataIndex } = pendingPromiseIndexes[i];
                         const finishedStep = _allSteps[allStepsIndex];
-                        const storeEntry = bucket.store.get(finishedStep.id);
                         if (settledResult.status === "fulfilled") {
-                            success(finishedStep, storeEntry, dataIndex, settledResult.value);
+                            success(finishedStep, bucket, dataIndex, settledResult.value, interfaces_js_1.NO_FLAGS);
                         }
                         else {
-                            bucket.hasErrors = true;
-                            storeEntry[dataIndex] = (0, error_js_1.newGrafastError)(settledResult.reason, finishedStep.id);
+                            const error = settledResult.reason;
+                            bucket.setResult(finishedStep, dataIndex, error, interfaces_js_1.FLAG_ERROR);
                         }
                     }
-                    if (bucket.hasErrors && sideEffectSteps) {
-                        handleSideEffectSteps();
-                    }
                     return promises ? Promise.all(promises) : undefined;
                 })
                     .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.hasErrors = true;
+                    bucket.flagUnion |= interfaces_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 storeEntry = bucket.store.get(finishedStep.id);
-                        storeEntry[dataIndex] = (0, error_js_1.newGrafastError)(new Error(`GrafastInternalError<1e9731b4-005e-4b0e-bc61-43baa62e6444>: error occurred whilst performing completedStep(${finishedStep.id})`), finishedStep.id);
+                        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);
                     }
                 });
             }
             else {
-                if (bucket.hasErrors && sideEffectSteps) {
-                    handleSideEffectSteps();
-                }
                 return promises ? Promise.all(promises) : undefined;
             }
         };
         const runSyncSteps = () => {
-            const executedLength = results.length;
+            const executedLength = resultList.length;
             if (dev_js_1.isDev) {
                 assert.strictEqual(executedLength, phase.normalSteps?.length ?? 0, "Expected only and all normalSteps to have executed");
             }
@@ -351,48 +348,151 @@ function executeBucket(bucket, requestContext) {
                     stopTime,
                     meta,
                     eventEmitter,
+                    stream: evaluateStream(bucket, step),
                     _bucket: bucket,
                     _requestContext: requestContext,
                 };
-                bucket.store.set(step.id, (0, utils_js_1.arrayOfLength)(size));
-            }
-            outerLoop: for (let dataIndex = 0; dataIndex < size; dataIndex++) {
-                if (sideEffectStepsWithErrors) {
-                    const currentPolymorphicPath = bucket.polymorphicPathList[dataIndex];
-                    for (const dep of sideEffectStepsWithErrors[currentPolymorphicPath ?? NO_POLY_PATH]) {
-                        const depVal = bucket.store.get(dep.id)[dataIndex];
-                        if (depVal === POLY_SKIPPED ||
-                            (dev_js_1.isDev && depVal?.$$error === POLY_SKIPPED)) {
-                            /* noop */
-                        }
-                        else if ((0, error_js_1.isGrafastError)(depVal)) {
-                            for (let allStepsIndex = executedLength; allStepsIndex < allStepsLength; allStepsIndex++) {
-                                const step = _allSteps[allStepsIndex];
-                                const storeEntry = bucket.store.get(step.id);
-                                storeEntry[dataIndex] = depVal;
+                if (step._isUnary) {
+                    // Handled later
+                }
+                else {
+                    bucket.store.set(step.id, batchExecutionValue((0, utils_js_1.arrayOfLength)(size)));
+                }
+            }
+            for (let dataIndex = 0; dataIndex < size; dataIndex++) {
+                stepLoop: for (let allStepsIndex = executedLength; allStepsIndex < allStepsLength; allStepsIndex++) {
+                    const step = (0, utils_js_1.sudo)(_allSteps[allStepsIndex]);
+                    // Unary steps only need to be processed once
+                    if (step._isUnary && dataIndex !== 0) {
+                        continue;
+                    }
+                    // Check if the side effect errored
+                    const $sideEffect = step.implicitSideEffectStep;
+                    if ($sideEffect) {
+                        let currentPolymorphicPath;
+                        if ($sideEffect.polymorphicPaths === null ||
+                            (currentPolymorphicPath =
+                                bucket.polymorphicPathList[dataIndex]) === null ||
+                            $sideEffect.polymorphicPaths.has(currentPolymorphicPath)) {
+                            const depExecutionValue = bucket.store.get($sideEffect.id);
+                            if (depExecutionValue === undefined) {
+                                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) {
+                                /* noop */
+                            }
+                            else if (depFlags & interfaces_js_1.FLAG_ERROR) {
+                                if (step._isUnary) {
+                                    // COPY the unary value
+                                    bucket.store.set(step.id, depExecutionValue);
+                                    bucket.flagUnion |= depFlags;
+                                }
+                                else {
+                                    const depVal = depExecutionValue.at(dataIndex);
+                                    bucket.setResult(step, dataIndex, depVal, depFlags);
+                                }
+                                continue stepLoop;
                             }
-                            continue outerLoop;
                         }
                     }
-                }
-                stepLoop: for (let allStepsIndex = executedLength; allStepsIndex < allStepsLength; allStepsIndex++) {
-                    const step = _allSteps[allStepsIndex];
-                    const storeEntry = bucket.store.get(step.id);
                     try {
                         const deps = [];
-                        for (const $dep of step.dependencies) {
-                            const depVal = bucket.store.get($dep.id)[dataIndex];
-                            if (bucket.hasErrors && (0, error_js_1.isGrafastError)(depVal)) {
-                                storeEntry[dataIndex] = depVal;
-                                continue stepLoop;
+                        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;
+                                }
+                                if (forceIndexValue == null) {
+                                    if ((flags & interfaces_js_1.FLAG_ERROR) !== 0) {
+                                        const v = depExecutionVal.at(dataIndex);
+                                        forceIndexValue = v;
+                                    }
+                                    else {
+                                        forceIndexValue = null;
+                                    }
+                                }
+                                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);
+                                    }
+                                    continue stepLoop;
+                                }
+                                deps.push(depVal);
                             }
-                            deps.push(depVal);
                         }
-                        storeEntry[dataIndex] = step.unbatchedExecute(extras[allStepsIndex], ...deps);
+                        let stepResult, stepFlags;
+                        if (forceIndexValue !== undefined) {
+                            // Search for "17217999b7a7" for similar block
+                            if (forceIndexValue == null && rejectValue != null) {
+                                indexFlags |= interfaces_js_1.FLAG_ERROR;
+                                forceIndexValue = rejectValue;
+                            }
+                            else {
+                                indexFlags |= interfaces_js_1.FLAG_INHIBITED;
+                            }
+                            // End "17217999b7a7" block
+                            stepResult = forceIndexValue;
+                            stepFlags = indexFlags;
+                        }
+                        else {
+                            const rawStepResult = step.unbatchedExecute(extra, ...deps);
+                            if (typeof rawStepResult === "object" &&
+                                rawStepResult !== null &&
+                                (0, error_js_1.isFlaggedValue)(rawStepResult)) {
+                                stepResult = rawStepResult.value;
+                                stepFlags = rawStepResult.flags;
+                            }
+                            else {
+                                stepResult = rawStepResult;
+                                stepFlags = rawStepResult == null ? interfaces_js_1.FLAG_NULL : interfaces_js_1.NO_FLAGS;
+                            }
+                        }
+                        // TODO: what if stepResult is _returned_ error (as opposed to
+                        // thrown)?
+                        // NOTE: we are in `runSyncSteps` so this step is guaranteed to
+                        // be "isSyncAndSafe". As such, we don't need to worry about it
+                        // returning an error (unsafe) or a promise (async), we only
+                        // need to check if it's null.
+                        bucket.setResult(step, dataIndex, stepResult, stepFlags);
                     }
                     catch (e) {
-                        bucket.hasErrors = true;
-                        storeEntry[dataIndex] = (0, error_js_1.newGrafastError)(e, step.id);
+                        bucket.setResult(step, dataIndex, e, interfaces_js_1.FLAG_ERROR);
                     }
                 }
             }
@@ -411,7 +511,7 @@ function executeBucket(bucket, requestContext) {
                 const executePromise = executePromises[i];
                 const index = executePromiseResultIndex[i];
                 processedPromises.push(executePromise.then((promiseResult) => {
-                    results[index] = promiseResult;
+                    resultList[index] = promiseResult;
                     indexesPendingLoopOver.push(index);
                     // We must loop over the results in the same tick in which the
                     // promise resolved.
@@ -438,12 +538,26 @@ function executeBucket(bucket, requestContext) {
         return executeSamePhaseChildren();
     }
     // Function definitions below here
-    function executeOrStream(step, dependencies, extra) {
-        if (step._stepOptions.stream && (0, step_js_1.isStreamableStep)(step)) {
-            return step.stream(size, dependencies, extra, step._stepOptions.stream);
+    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`);
+        }
+        const executeDetails = {
+            indexMap: makeIndexMap(count),
+            indexForEach: makeIndexForEach(count),
+            count,
+            values,
+            extra,
+            stream: evaluateStream(bucket, step),
+        };
+        if (!step.isSyncAndSafe && middleware != null) {
+            return middleware.run("executeStep", { args, step, executeDetails }, executeStepFromEvent);
         }
         else {
-            return step.execute(size, dependencies, extra);
+            return step.execute(executeDetails);
         }
     }
     // Slow mode...
@@ -452,107 +566,200 @@ function executeBucket(bucket, requestContext) {
      * polymorphicPaths from the input dependencies and then padding the lists
      * back out at the end.
      */
-    function reallyExecuteStepWithErrorsOrSelective(step, dependenciesIncludingSideEffects, polymorphicPathList, extra) {
-        const errors = Object.create(null);
-        /** If there's errors, we must manipulate the arrays being passed into the step execution */
-        let foundErrors = false;
+    function reallyExecuteStepWithFiltering(step, dependenciesIncludingSideEffects, dependencyForbiddenFlags, dependencyOnReject, polymorphicPathList, extra) {
+        const expectedSize = step._isUnary ? 1 : size;
+        const forcedValues = {
+            flags: (0, utils_js_1.arrayOfLength)(expectedSize, undefined),
+            results: (0, utils_js_1.arrayOfLength)(expectedSize, undefined),
+        };
+        /**
+         * If there's errors/forbidden values, we must manipulate the arrays being
+         * passed into the step execution
+         */
+        let needsTransform = false;
         /** If all we see is errors, there's no need to execute! */
-        let needsNoExecution = true;
-        const stepPolymorphicPaths = step.polymorphicPaths;
-        for (let index = 0, l = polymorphicPathList.length; index < l; index++) {
-            const polymorphicPath = polymorphicPathList[index];
+        let newSize = 0;
+        let stepPolymorphicPaths = step.polymorphicPaths;
+        const legitDepsCount = (0, utils_js_1.sudo)(step).dependencies.length;
+        const dependenciesIncludingSideEffectsCount = dependenciesIncludingSideEffects.length;
+        let dependencies = dependenciesIncludingSideEffectsCount > legitDepsCount
+            ? dependenciesIncludingSideEffects.slice(0, legitDepsCount)
+            : dependenciesIncludingSideEffects;
+        // OPTIM: if unariesIncludingSideEffects.some(isGrafastError) then shortcut execution because everything fails
+        let hasPolyMatch = true;
+        if (step._isUnary && stepPolymorphicPaths !== null) {
+            // Check that at least one datapoint matches one of our paths
+            hasPolyMatch = false;
+            for (let dataIndex = 0; dataIndex < size; dataIndex++) {
+                if (stepPolymorphicPaths.has(polymorphicPathList[dataIndex])) {
+                    hasPolyMatch = true;
+                    break;
+                }
+            }
+            stepPolymorphicPaths = null;
+        }
+        for (let dataIndex = 0; dataIndex < expectedSize; dataIndex++) {
+            let forceIndexValue = hasPolyMatch
+                ? undefined
+                : null;
+            let rejectValue = undefined;
+            let indexFlags = hasPolyMatch
+                ? interfaces_js_1.NO_FLAGS
+                : interfaces_js_1.FLAG_POLY_SKIPPED;
             if (stepPolymorphicPaths !== null &&
-                !stepPolymorphicPaths.has(polymorphicPath)) {
-                foundErrors = true;
-                const e = dev_js_1.isDev && DEBUG_POLYMORPHISM
-                    ? Object.assign((0, error_js_1.newGrafastError)(new Error(`GrafastInternalError<00d52055-06b0-4b25-abeb-311b800ea284>: step ${step.id} (polymorphicPaths ${[
-                        ...stepPolymorphicPaths,
-                    ]}) has no match for '${polymorphicPath}'`), step.id), { $$error: POLY_SKIPPED })
-                    : POLY_SKIPPED;
-                errors[index] = e;
-            }
-            else if (extra._bucket.hasErrors) {
-                let noError = true;
-                for (const depList of dependenciesIncludingSideEffects) {
-                    const v = depList[index];
-                    if ((0, error_js_1.isGrafastError)(v)) {
-                        if (!errors[index]) {
-                            noError = false;
-                            foundErrors = true;
-                            errors[index] = v;
-                            break;
+                !stepPolymorphicPaths.has(polymorphicPathList[dataIndex])) {
+                indexFlags |= interfaces_js_1.FLAG_POLY_SKIPPED;
+                forceIndexValue = null;
+            }
+            else if (extra._bucket.flagUnion) {
+                for (let i = 0; i < dependenciesIncludingSideEffectsCount; i++) {
+                    const depExecutionVal = dependenciesIncludingSideEffects[i];
+                    const forbiddenFlags = dependencyForbiddenFlags[i];
+                    const onReject = dependencyOnReject[i];
+                    // 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;
+                        }
+                        if (forceIndexValue == null) {
+                            if ((flags & interfaces_js_1.FLAG_ERROR) !== 0) {
+                                const v = depExecutionVal.at(dataIndex);
+                                forceIndexValue = v;
+                            }
+                            else {
+                                forceIndexValue = null;
+                            }
+                        }
+                        else {
+                            // First error wins, ignore this second error.
                         }
+                        // End "f2b3b1b3" block
+                        break;
                     }
                 }
-                if (noError) {
-                    needsNoExecution = false;
+            }
+            else {
+                // All good
+            }
+            if (forceIndexValue !== undefined) {
+                if (!needsTransform) {
+                    needsTransform = true;
+                    // Clone up until this point, make mutable, don't add self
+                    dependencies = dependencies.map((ev) => ev.isBatch
+                        ? // TODO: move this creation to happen once the full list is
+                            // already built, ideally we shouldn't be mutating an execution
+                            // value later.
+                            batchExecutionValue(ev.entries.slice(0, dataIndex))
+                        : ev);
+                }
+                // Search for "17217999b7a7" for similar block
+                if (forceIndexValue == null && rejectValue != null) {
+                    indexFlags |= interfaces_js_1.FLAG_ERROR;
+                    forceIndexValue = rejectValue;
+                }
+                else {
+                    indexFlags |= interfaces_js_1.FLAG_INHIBITED;
                 }
+                // End "17217999b7a7" block
+                forcedValues.flags[dataIndex] = indexFlags;
+                forcedValues.results[dataIndex] = forceIndexValue;
             }
             else {
-                needsNoExecution = false;
+                newSize++;
+                if (needsTransform) {
+                    // dependenciesWithoutErrors has limited content; add this non-error value
+                    for (let depListIndex = 0; depListIndex < legitDepsCount; depListIndex++) {
+                        const depList = dependencies[depListIndex];
+                        if (depList.isBatch) {
+                            const depVal = dependenciesIncludingSideEffects[depListIndex];
+                            depList.entries.push(depVal.at(dataIndex));
+                            depList._flags.push(depVal._flagsAt(dataIndex));
+                        }
+                    }
+                }
             }
         }
-        // Trim the side-effect dependencies back out again
-        const dependencies = sideEffectStepsWithErrors
-            ? dependenciesIncludingSideEffects.slice(0, step.dependencies.length)
-            : dependenciesIncludingSideEffects;
-        if (needsNoExecution) {
+        if (newSize === 0) {
             // Everything is errors; we can skip execution
-            return Object.values(errors);
+            return forcedValues;
         }
-        else if (foundErrors) {
-            const dependenciesWithoutErrors = dependencies.map((depList) => depList.filter((_, index) => !errors[index]));
-            const resultWithoutErrors = executeOrStream(step, dependenciesWithoutErrors, extra);
+        else if (needsTransform) {
+            const resultWithoutErrors = executeOrStream(newSize, step, dependencies, extra);
             if ((0, utils_js_1.isPromiseLike)(resultWithoutErrors)) {
-                return resultWithoutErrors.then((r) => mergeErrorsBackIn(r, errors, dependencies[0].length));
+                return resultWithoutErrors.then((r) => mergeErrorsBackIn(r, forcedValues, expectedSize));
             }
             else {
-                return mergeErrorsBackIn(resultWithoutErrors, errors, dependencies[0].length);
+                return mergeErrorsBackIn(resultWithoutErrors, forcedValues, expectedSize);
             }
         }
         else {
-            return reallyExecuteStepWithNoErrors(step, dependencies, extra);
+            if (dev_js_1.isDev) {
+                assert.ok(newSize === expectedSize, "GrafastInternalError<47fca4ab-069c-428f-8374-267479c7fd27>: Expected newSize to equal expectedSize");
+            }
+            return reallyExecuteStepWithoutFiltering(newSize, step, dependencies, extra);
         }
     }
     /**
      * This function MIGHT throw or reject, so be sure to handle that.
      */
     function executeStep(step) {
+        // DELIBERATE SHADOWING!
+        const size = step._isUnary ? 1 : bucket.size;
         try {
             const meta = step.metaKey !== undefined ? metaByMetaKey[step.metaKey] : undefined;
             const extra = {
                 stopTime,
                 meta,
                 eventEmitter,
+                stream: evaluateStream(bucket, step),
                 _bucket: bucket,
                 _requestContext: requestContext,
             };
-            const dependencies = [];
-            const depCount = step.dependencies.length;
-            if (depCount > 0 || sideEffectStepsWithErrors !== null) {
+            /** Only mutate this inside `addDependency` */
+            const _rawDependencies = [];
+            const _rawForbiddenFlags = [];
+            const _rawOnReject = [];
+            const dependencies = _rawDependencies;
+            let needsFiltering = false;
+            const defaultForbiddenFlags = (0, utils_js_1.sudo)(step).defaultForbiddenFlags;
+            const addDependency = ($dep, forbiddenFlags, onReject) => {
+                if (step._isUnary && !$dep._isUnary) {
+                    throw new Error(`GrafastInternalError<58bc38e2-8722-4c19-ba38-fd01a020654b>: unary step ${step} cannot be made dependent on non-unary step ${$dep}!`);
+                }
+                const executionValue = store.get($dep.id);
+                if (executionValue === undefined) {
+                    throw new Error(`GrafastInternalError<d9e9eb37-4251-4659-a545-4730826ecf0e>: ${$dep} data couldn't be found, but required by ${step} (with side effect ${step.implicitSideEffectStep})!`);
+                }
+                _rawDependencies.push(executionValue);
+                _rawForbiddenFlags.push(forbiddenFlags);
+                _rawOnReject.push(onReject);
+                if (!needsFiltering && (bucket.flagUnion & forbiddenFlags) !== 0) {
+                    const flags = executionValue._getStateUnion();
+                    needsFiltering = (flags & forbiddenFlags) !== 0;
+                }
+            };
+            const sstep = (0, utils_js_1.sudo)(step);
+            const depCount = sstep.dependencies.length;
+            if (depCount > 0) {
                 for (let i = 0, l = depCount; i < l; i++) {
-                    const $dep = step.dependencies[i];
-                    dependencies[i] = store.get($dep.id);
-                }
-                if (sideEffectStepsWithErrors !== null) {
-                    if (step.polymorphicPaths) {
-                        for (const path of step.polymorphicPaths) {
-                            for (const sideEffectStep of sideEffectStepsWithErrors[path]) {
-                                const sideEffectStoreEntry = store.get(sideEffectStep.id);
-                                if (!dependencies.includes(sideEffectStoreEntry)) {
-                                    dependencies.push(sideEffectStoreEntry);
-                                }
-                            }
-                        }
-                    }
-                    else {
-                        for (const sideEffectStep of sideEffectStepsWithErrors[NO_POLY_PATH]) {
-                            const sideEffectStoreEntry = store.get(sideEffectStep.id);
-                            if (!dependencies.includes(sideEffectStoreEntry)) {
-                                dependencies.push(sideEffectStoreEntry);
-                            }
-                        }
-                    }
+                    const $dep = sstep.dependencies[i];
+                    addDependency($dep, sstep.dependencyForbiddenFlags[i], sstep.dependencyOnReject[i]);
+                }
+            }
+            const $sideEffect = step.implicitSideEffectStep;
+            if ($sideEffect) {
+                if ($sideEffect._isUnary || !step._isUnary) {
+                    addDependency($sideEffect, defaultForbiddenFlags, undefined);
                 }
             }
             if (dev_js_1.isDev &&
@@ -560,16 +767,24 @@ function executeBucket(bucket, requestContext) {
                 step.polymorphicPaths === null) {
                 throw new Error(`GrafastInternalError<c33328fe-6758-4699-8ac6-7be41ce58bfb>: a step without polymorphic paths cannot belong to a polymorphic bucket`);
             }
-            const isSelectiveStep = step.layerPlan.reason.type === "polymorphic" &&
-                step.polymorphicPaths.size !==
-                    step.layerPlan.reason.polymorphicPaths.size;
-            const result = bucket.hasErrors || isSelectiveStep
-                ? reallyExecuteStepWithErrorsOrSelective(step, dependencies, bucket.polymorphicPathList, extra)
-                : reallyExecuteStepWithNoErrors(step, dependencies, extra);
+            if (!needsFiltering) {
+                const isSelectiveStep = step.layerPlan.reason.type === "polymorphic" &&
+                    step.polymorphicPaths.size !==
+                        step.layerPlan.reason.polymorphicPaths.size;
+                needsFiltering ||= isSelectiveStep;
+            }
+            const result = needsFiltering
+                ? reallyExecuteStepWithFiltering(step, dependencies, _rawForbiddenFlags, _rawOnReject, bucket.polymorphicPathList, extra)
+                : reallyExecuteStepWithoutFiltering(size, step, $sideEffect ? dependencies.slice(0, depCount) : dependencies, extra);
             if ((0, utils_js_1.isPromiseLike)(result)) {
                 return result.then(null, (error) => {
-                    // bucket.hasErrors = true;
-                    return (0, utils_js_1.arrayOfLength)(size, error);
+                    // Don't need to do this here, it will be done where the
+                    // ExecutionValue is created:
+                    //   bucket.hasNonZeroStatus = true;
+                    return {
+                        flags: (0, utils_js_1.arrayOfLength)(size, interfaces_js_1.FLAG_ERROR | interfaces_js_1.FLAG_STOPPED),
+                        results: (0, utils_js_1.arrayOfLength)(size, error),
+                    };
                 });
             }
             else {
@@ -577,8 +792,13 @@ function executeBucket(bucket, requestContext) {
             }
         }
         catch (error) {
-            // bucket.hasErrors = true;
-            return (0, utils_js_1.arrayOfLength)(size, error);
+            // Don't need to do this here, it will be done where the
+            // ExecutionValue is created:
+            //   bucket.hasNonZeroStatus = true;
+            return {
+                flags: (0, utils_js_1.arrayOfLength)(size, interfaces_js_1.FLAG_ERROR | interfaces_js_1.FLAG_STOPPED),
+                results: (0, utils_js_1.arrayOfLength)(size, error),
+            };
         }
     }
     function executeSamePhaseChildren() {
@@ -591,8 +811,10 @@ function executeBucket(bucket, requestContext) {
          * are called.
          */
         const enqueue = (callback) => {
-            const result = (mutationQueue ?? Promise.resolve()).then(callback);
-            mutationQueue = result.then(noop, noop);
+            const result = mutationQueue ? mutationQueue.then(callback) : callback();
+            if ((0, utils_js_1.isPromiseLike)(result)) {
+                mutationQueue = result.then(noop, noop);
+            }
             return result;
         };
         loop: for (const childLayerPlan of childLayerPlans) {
@@ -615,7 +837,9 @@ function executeBucket(bucket, requestContext) {
                     if (childBucket !== null) {
                         // Enqueue for execution (mutations must run in order)
                         const promise = enqueue(() => executeBucket(childBucket, requestContext));
-                        childPromises.push(promise);
+                        if ((0, utils_js_1.isPromiseLike)(promise)) {
+                            childPromises.push(promise);
+                        }
                     }
                     break;
                 }
@@ -648,7 +872,6 @@ function executeBucket(bucket, requestContext) {
         }
     }
 }
-exports.executeBucket = executeBucket;
 /** @internal */
 function newBucket(spec, parentMetaByMetaKey) {
     if (dev_js_1.isDev) {
@@ -668,8 +891,10 @@ function newBucket(spec, parentMetaByMetaKey) {
         }
         */
         for (const [key, list] of spec.store.entries()) {
-            assert.ok(Array.isArray(list), `Store entry for step '${key}' for layerPlan '${spec.layerPlan.id}' should be a list`);
-            assert.strictEqual(list.length, spec.size, `Store entry for step '${key}' for layerPlan '${spec.layerPlan.id}' should have same length as bucket`);
+            assert.ok(typeof list.isBatch === "boolean", `Store entry for step '${key}' for layerPlan '${spec.layerPlan.id}' should be an ExecutionValue`);
+            if (list.isBatch) {
+                assert.strictEqual(list.entries.length, spec.size, `Store entry for step '${key}' for layerPlan '${spec.layerPlan.id}' should have same length as bucket`);
+            }
         }
         if (!spec.iterators) {
             throw new Error(`newBucket called but no iterators array was specified`);
@@ -683,18 +908,195 @@ function newBucket(spec, parentMetaByMetaKey) {
         ? // Reset the metaByMetaKey
             spec.layerPlan.operationPlan.makeMetaByMetaKey()
         : parentMetaByMetaKey;
+    // Copy from spec
+    const { layerPlan, store, size, flagUnion, polymorphicPathList, iterators } = spec;
+    const children = Object.create(null);
     return {
-        // Copy from spec
-        layerPlan: spec.layerPlan,
-        store: spec.store,
-        size: spec.size,
-        hasErrors: spec.hasErrors,
-        polymorphicPathList: spec.polymorphicPathList,
-        iterators: spec.iterators,
+        toString: bucketToString,
+        layerPlan,
+        store,
+        size,
+        flagUnion,
+        polymorphicPathList,
+        iterators,
         metaByMetaKey,
         isComplete: false,
-        children: Object.create(null),
+        children,
+        setResult(step, index, value, flags) {
+            const stepId = step.id;
+            if (index >= size) {
+                throw new Error(`GrafastInternalError<9465db89-cc9d-415c-97e7-57bb19ddebe0>: attempt to write to out of bounds index ${index} for bucket of size ${size} for step ${step}`);
+            }
+            if (flags !== 0) {
+                this.flagUnion |= flags;
+            }
+            if (step._isUnary) {
+                if (dev_js_1.isDev && store.has(stepId)) {
+                    const ev = store.get(stepId);
+                    console.error(`GrafastInternalWarning<603e635f-af46-4feb-abb1-bac184bf7ef2>: value for step ${step} has already been stored to bucket ${layerPlan}; overwriting.`, {
+                        isBatch: ev?.isBatch,
+                        value0: ev?.at(0),
+                        flags0: ev?._flagsAt(0),
+                    }, { isBatch: false, value, flags });
+                }
+                const ev = unaryExecutionValue(value, flags);
+                store.set(stepId, ev);
+            }
+            else {
+                const storeEntry = store.get(stepId);
+                if (!storeEntry || !storeEntry.isBatch) {
+                    if (!storeEntry) {
+                        throw new Error(`GrafastInternalError<e2ba1e4a-5391-4f81-bb21-fb200e29aea2>: value for step ${step} expected to be a batch value, but is not set`);
+                    }
+                    else {
+                        throw new Error(`GrafastInternalError<f587d317-8919-4f14-905a-ab7bb338dd2b>: value for step ${step} expected to be a batch value, but is unary (non-batch)`);
+                    }
+                }
+                storeEntry._setResult(index, value, flags);
+            }
+        },
     };
 }
-exports.newBucket = newBucket;
+function bucketToString() {
+    return `Bucket<${this.layerPlan}>`;
+}
+// NOTE: I evaluated using `__proto__: batchExecutionValueProto` to extract the
+// shared properties of these objects to see if performance was improved, but
+// this was actually a net loss in performance.
+//
+// This is also evidence that you shouldn't trust ChatGPT for performance
+// advice, and should always run your own benchmarks instead:
+// https://chatgpt.com/share/67d1746f-4da8-8012-bdf8-707e54a4238e
+// TODO: memoize?
+function batchExecutionValue(entries, _flags = (0, utils_js_1.arrayOfLength)(entries.length, 0)) {
+    return {
+        // Try and keep these properties in the same order as unaryExecutionValue
+        isBatch: true,
+        at: batchEntriesAt,
+        unaryValue: batchThrowNotUnary,
+        _flagsAt: batchFlagsAt,
+        _getStateUnion: batchGetStateUnion,
+        _setResult: batchSetResult,
+        _copyResult: batchCopyResult,
+        entries,
+        _flags,
+        _cachedStateUnion: null,
+    };
+}
+// TODO: memoize?
+function unaryExecutionValue(value, _entryFlags = 0) {
+    return {
+        // Try and keep these properties in the same order as batchExecutionValue
+        isBatch: false,
+        at: unaryAt,
+        unaryValue: unaryThisDotValue,
+        _flagsAt: unaryFlagsAt,
+        _getStateUnion: unaryGetStateUnion,
+        _setResult: unarySetResult,
+        _copyResult: unaryCopyResult,
+        value,
+        _entryFlags,
+    };
+}
+function batchThrowNotUnary() {
+    throw new Error(`This is not a unary value so we cannot get the single value - there may be more than one!`);
+}
+function batchGetStateUnion() {
+    if (this._cachedStateUnion === null) {
+        let u = interfaces_js_1.NO_FLAGS;
+        for (const flag of this._flags) {
+            u = u | flag;
+        }
+        this._cachedStateUnion = u;
+    }
+    return this._cachedStateUnion;
+}
+function batchEntriesAt(i) {
+    return this.entries[i];
+}
+function batchFlagsAt(i) {
+    return this._flags[i];
+}
+function batchSetResult(i, value, flags) {
+    this.entries[i] = value;
+    this._flags[i] = flags;
+}
+// NOTE: batchCopyResult and unaryCopyResult are **identical**, but we don't
+// want a single megamorphic function so we define it twice.
+function batchCopyResult(targetIndex, source, sourceIndex) {
+    this._setResult(targetIndex, source.at(sourceIndex), source._flagsAt(sourceIndex));
+}
+function unaryCopyResult(targetIndex, source, sourceIndex) {
+    this._setResult(targetIndex, source.at(sourceIndex), source._flagsAt(sourceIndex));
+}
+function unaryThisDotValue() {
+    return this.value;
+}
+function unaryAt() {
+    return this.value;
+}
+function unaryFlagsAt() {
+    return this._entryFlags;
+}
+function unaryGetStateUnion() {
+    return this._entryFlags;
+}
+function unarySetResult(i, value, flags) {
+    if (i !== 0) {
+        throw new Error(`Unary step only expects one result`);
+    }
+    this.value = value;
+    this._entryFlags = flags;
+}
+const indexMapCache = new Map();
+function makeIndexMap(count) {
+    const existing = indexMapCache.get(count);
+    if (existing !== undefined) {
+        return existing;
+    }
+    const result = (callback) => {
+        const results = [];
+        for (let i = 0; i < count; i++) {
+            results.push(callback(i));
+        }
+        return results;
+    };
+    if (count <= 100) {
+        indexMapCache.set(count, result);
+    }
+    return result;
+}
+const indexForEachCache = new Map();
+function makeIndexForEach(count) {
+    const existing = indexForEachCache.get(count);
+    if (existing !== undefined) {
+        return existing;
+    }
+    const result = (callback) => {
+        for (let i = 0; i < count; i++) {
+            callback(i);
+        }
+    };
+    if (count <= 100) {
+        indexForEachCache.set(count, result);
+    }
+    return result;
+}
+function executeStepFromEvent(event) {
+    return event.step.execute(event.executeDetails);
+}
+function evaluateStream(bucket, step) {
+    const stream = step._stepOptions.stream;
+    if (!stream)
+        return null;
+    const shouldStream = stream.ifStepId == null
+        ? true
+        : (bucket.store.get(stream.ifStepId)?.unaryValue() ?? true);
+    if (!shouldStream)
+        return null;
+    const initialCount = stream.initialCountStepId == null
+        ? 0
+        : (bucket.store.get(stream.initialCountStepId)?.unaryValue() ?? 0);
+    return { initialCount };
+}
 //# sourceMappingURL=executeBucket.js.map