grafast 0.1.1-beta.20 → 0.1.1-beta.21

package/dist/engine/OutputPlan.d.ts

@@ -3,7 +3,7 @@ import type { FieldNode, GraphQLEnumType, GraphQLObjectType, GraphQLScalarType }
 import * as graphql from "graphql";
 import type { Bucket } from "../bucket.js";
 import type { ExecutionEntryFlags, JSONValue, LocationDetails } from "../interfaces.js";
-import type { ExecutableStep } from "../step.js";
+import type { Step } from "../step.js";
 import type { PayloadRoot } from "./executeOutputPlan.js";
 import type { LayerPlan } from "./LayerPlan.js";
 export type OutputPlanTypeIntrospection = {
@@ -115,12 +115,12 @@ export declare class OutputPlan<TType extends OutputPlanType = OutputPlanType> {
      * The step that represents the root value. How this is used depends on the
      * OutputPlanMode.
      */
-    readonly rootStep: ExecutableStep;
+    readonly rootStep: Step;
     /**
      * If this output plan should resolve to an error if a side effect step
      * raises an error, this is that side effect.
      */
-    readonly sideEffectStep: ExecutableStep | null;
+    readonly sideEffectStep: Step | null;
     /**
      * For root/object output plans, the keys to set on the resulting object
      * grouped by the concrete object type name.
@@ -160,7 +160,7 @@ export declare class OutputPlan<TType extends OutputPlanType = OutputPlanType> {
      *
      * For `introspection`, `null` it's irrelevant. Use `constant(null)` or whatever.
      */
-    rootStep: ExecutableStep, type: TType, locationDetails: LocationDetails);
+    rootStep: Step, type: TType, locationDetails: LocationDetails);
     print(): string;
     toString(): string;
     addChild(type: GraphQLObjectType | null, key: string | null, child: OutputPlanKeyValue): void;

package/dist/engine/OutputPlan.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getChildBucketAndIndex = exports.nonNullError = exports.coerceError = exports.OutputPlan = void 0;
+exports.OutputPlan = void 0;
+exports.coerceError = coerceError;
+exports.nonNullError = nonNullError;
+exports.getChildBucketAndIndex = getChildBucketAndIndex;
 const tslib_1 = require("tslib");
 const lru_1 = tslib_1.__importDefault(require("@graphile/lru"));
 const graphql = tslib_1.__importStar(require("graphql"));
@@ -221,7 +224,7 @@ class OutputPlan {
             const expressionDetails = $root.unbatchedExecute[access_js_1.expressionSymbol];
             if (expressionDetails !== undefined) {
                 // @ts-ignore
-                const $parent = $root.getDep(0);
+                const { step: $parent } = $root.getDepOptions(0);
                 this.layerPlan.operationPlan.stepTracker.setOutputPlanRootStep(this, $parent);
                 const [path, fallback] = expressionDetails;
                 withFastExpression(path, fallback, (fn) => {
@@ -359,10 +362,9 @@ function coerceError(error, locationDetails, path) {
         }
     }
     else {
-        return new GraphQLError(error.message, locationDetails.node, null, null, path, error, null);
+        return new GraphQLError(error?.message ?? String(error), locationDetails.node, null, null, path, error, null);
     }
 }
-exports.coerceError = coerceError;
 function nonNullError(locationDetails, path) {
     const { parentTypeName, fieldName, node } = locationDetails;
     if (!parentTypeName || !fieldName) {
@@ -370,7 +372,6 @@ function nonNullError(locationDetails, path) {
     }
     return new GraphQLError(`Cannot return null for non-nullable field ${parentTypeName}.${fieldName}.`, node, null, null, path, null, null);
 }
-exports.nonNullError = nonNullError;
 /**
  * We're currently running OutputPlan `outputPlan` in bucket `bucket` at index
  * `bucketIndex`. If this is an array OutputPlan then we're looping over the
@@ -448,7 +449,6 @@ function getChildBucketAndIndex(layerPlan, outputPlan, bucket, bucketIndex, arra
     }
     return [currentBucket, currentIndex];
 }
-exports.getChildBucketAndIndex = getChildBucketAndIndex;
 function makeExecutor(config) {
     const { preamble = null, inner, asString, nameExtra, skipNullHandling = false, } = config;
     const fn = function (root, mutablePath, bucket, bucketIndex, rawBucketRootValue = bucket.store.get(this.rootStep.id).at(bucketIndex), bucketRootFlags = bucket.store.get(this.rootStep.id)._flagsAt(bucketIndex)) {
@@ -467,6 +467,9 @@ function makeExecutor(config) {
                 }
             }
         }
+        if (bucketRootFlags & interfaces_js_1.FLAG_ERROR) {
+            throw coerceError(rawBucketRootValue, this.locationDetails, mutablePath.slice(1));
+        }
         const bucketRootValue = this.processRoot !== null
             ? this.processRoot(rawBucketRootValue, bucketRootFlags)
             : rawBucketRootValue;
@@ -474,9 +477,6 @@ function makeExecutor(config) {
         if (earlyReturn !== undefined) {
             return earlyReturn;
         }
-        if (bucketRootFlags & interfaces_js_1.FLAG_ERROR) {
-            throw coerceError(bucketRootValue, this.locationDetails, mutablePath.slice(1));
-        }
         if (!skipNullHandling) {
             if (bucketRootValue == null)
                 return (asString ? "null" : null);
@@ -770,13 +770,16 @@ function makeArrayExecutor(childIsNonNull, canStream, asString) {
             if (canStream) {
                 const stream = bucketRootValue[interfaces_js_1.$$streamMore];
                 if (stream !== undefined) {
+                    const labelStepId = childOutputPlan.layerPlan.reason.stream?.labelStepId;
                     root.streams.push({
                         root,
                         path: mutablePath.slice(1),
                         bucket,
                         bucketIndex,
                         outputPlan: childOutputPlan,
-                        label: childOutputPlan.layerPlan.reason.stream?.label,
+                        label: labelStepId != null
+                            ? bucket.store.get(labelStepId)?.unaryValue()
+                            : undefined,
                         stream,
                         startIndex: bucketRootValue.length,
                     });

package/dist/engine/StepTracker.js

@@ -32,6 +32,8 @@ class StepTracker {
         /** @internal */
         this.stepsWithNoDependenciesByConstructor = new Map();
         /** @internal */
+        this.internalDependencies = new Set();
+        /** @internal */
         this.outputPlansByRootStep = new Map();
         /** @internal */
         this.layerPlansByRootStep = new Map();
@@ -226,7 +228,7 @@ class StepTracker {
         if ($dependent.isFinalized) {
             throw new Error("You cannot add a dependency after the step is finalized.");
         }
-        if (!($dependency instanceof step_js_1.ExecutableStep)) {
+        if (!($dependency instanceof step_js_1.Step)) {
             throw new Error(`Error occurred when adding dependency for '${$dependent}', value passed was not a step, it was '${(0, inspect_js_1.inspect)($dependency)}'`);
         }
         if (dev_js_1.isDev) {
@@ -274,7 +276,8 @@ class StepTracker {
     addStepUnaryDependency($dependent, options) {
         const $dependency = options.step;
         if (!$dependency._isUnary) {
-            throw new Error(`${$dependent} attempted to create a unary step dependency on ${$dependency}, but that step is not unary. You may use \`.addDependency()\` instead of \`.addUnaryDependency()\`.`);
+            const { nonUnaryMessage = defaultNonUnaryMessage } = options;
+            throw new Error(nonUnaryMessage($dependent, $dependency));
         }
         $dependency._isUnaryLocked = true;
         return this.addStepDependency($dependent, options);
@@ -441,6 +444,9 @@ class StepTracker {
             return false;
         if ($step.hasSideEffects)
             return false;
+        if (this.internalDependencies.has($step)) {
+            return false;
+        }
         const s1 = this.outputPlansByRootStep.get($step);
         if (s1 && s1.size !== 0)
             return false;
@@ -586,4 +592,7 @@ class StepTracker {
     }
 }
 exports.StepTracker = StepTracker;
+function defaultNonUnaryMessage($dependent, $dependency) {
+    return `${$dependent} attempted to create a unary step dependency on ${$dependency}, but that step is not unary. See https://err.red/gud`;
+}
 //# sourceMappingURL=StepTracker.js.map

package/dist/engine/executeBucket.js

@@ -1,6 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.unaryExecutionValue = exports.batchExecutionValue = exports.bucketToString = 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,7 +12,6 @@ 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 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 })));
@@ -89,9 +92,11 @@ function executeBucket(bucket, requestContext) {
             if (phase.normalSteps !== undefined) {
                 const normalSteps = phase.normalSteps;
                 for (let normalStepIndex = 0, l = normalSteps.length; normalStepIndex < l; normalStepIndex++) {
+                    const step = normalSteps[normalStepIndex].step;
+                    const stepSize = step._isUnary ? 1 : bucket.size;
                     const r = timeoutError;
-                    const results = (0, utils_js_1.arrayOfLength)(bucket.size, r);
-                    const flags = (0, utils_js_1.arrayOfLength)(bucket.size, interfaces_js_1.FLAG_ERROR);
+                    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);
                     // TODO: I believe we can remove this line?
@@ -103,6 +108,7 @@ function executeBucket(bucket, requestContext) {
             const normalSteps = phase.normalSteps;
             for (let normalStepIndex = 0, l = normalSteps.length; normalStepIndex < l; normalStepIndex++) {
                 const step = normalSteps[normalStepIndex].step;
+                const stepSize = step._isUnary ? 1 : bucket.size;
                 try {
                     const r = executeStep(step);
                     if ((0, utils_js_1.isPromiseLike)(r)) {
@@ -123,8 +129,8 @@ function executeBucket(bucket, requestContext) {
                 }
                 catch (e) {
                     const r = e;
-                    const results = (0, utils_js_1.arrayOfLength)(bucket.size, r);
-                    const flags = (0, utils_js_1.arrayOfLength)(bucket.size, interfaces_js_1.FLAG_ERROR);
+                    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);
                     // TODO: I believe we can remove this line?
@@ -196,15 +202,12 @@ function executeBucket(bucket, requestContext) {
                     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]();
@@ -345,6 +348,7 @@ function executeBucket(bucket, requestContext) {
                     stopTime,
                     meta,
                     eventEmitter,
+                    stream: evaluateStream(bucket, step),
                     _bucket: bucket,
                     _requestContext: requestContext,
                 };
@@ -538,43 +542,22 @@ function executeBucket(bucket, requestContext) {
         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`);
         }
-        const streamOptions = step._stepOptions.stream;
-        if (streamOptions && (0, step_js_1.isStreamableStep)(step)) {
-            if (step.stream.length > 1) {
-                throw new Error(`${step} is using a legacy form of 'stream' which accepts multiple arguments, please see https://err.red/gev2`);
-            }
-            const streamDetails = {
-                indexMap: makeIndexMap(count),
-                indexForEach: makeIndexForEach(count),
-                count,
-                values,
-                extra,
-                streamOptions,
-            };
-            if (!step.isSyncAndSafe && middleware != null) {
-                return middleware.run("streamStep", { args, step, streamDetails }, streamStepFromEvent);
-            }
-            else {
-                return step.stream(streamDetails);
-            }
+        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 {
-            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,
-            };
-            if (!step.isSyncAndSafe && middleware != null) {
-                return middleware.run("executeStep", { args, step, executeDetails }, executeStepFromEvent);
-            }
-            else {
-                return step.execute(executeDetails);
-            }
+            return step.execute(executeDetails);
         }
     }
     // Slow mode...
@@ -596,24 +579,40 @@ function executeBucket(bucket, requestContext) {
         let needsTransform = false;
         /** If all we see is errors, there's no need to execute! */
         let newSize = 0;
-        const stepPolymorphicPaths = step.polymorphicPaths;
+        let stepPolymorphicPaths = step.polymorphicPaths;
         const legitDepsCount = (0, utils_js_1.sudo)(step).dependencies.length;
-        let dependencies = step.implicitSideEffectStep
+        const dependenciesIncludingSideEffectsCount = dependenciesIncludingSideEffects.length;
+        let dependencies = dependenciesIncludingSideEffectsCount > legitDepsCount
             ? dependenciesIncludingSideEffects.slice(0, legitDepsCount)
             : dependenciesIncludingSideEffects;
         // OPTIM: if unariesIncludingSideEffects.some(isGrafastError) then shortcut execution because everything fails
-        // for (let index = 0, l = polymorphicPathList.length; index < l; index++) {
+        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 = undefined;
+            let forceIndexValue = hasPolyMatch
+                ? undefined
+                : null;
             let rejectValue = undefined;
-            let indexFlags = interfaces_js_1.NO_FLAGS;
+            let indexFlags = hasPolyMatch
+                ? interfaces_js_1.NO_FLAGS
+                : interfaces_js_1.FLAG_POLY_SKIPPED;
             if (stepPolymorphicPaths !== null &&
                 !stepPolymorphicPaths.has(polymorphicPathList[dataIndex])) {
                 indexFlags |= interfaces_js_1.FLAG_POLY_SKIPPED;
                 forceIndexValue = null;
             }
             else if (extra._bucket.flagUnion) {
-                for (let i = 0, l = dependenciesIncludingSideEffects.length; i < l; i++) {
+                for (let i = 0; i < dependenciesIncludingSideEffectsCount; i++) {
                     const depExecutionVal = dependenciesIncludingSideEffects[i];
                     const forbiddenFlags = dependencyForbiddenFlags[i];
                     const onReject = dependencyOnReject[i];
@@ -714,12 +713,15 @@ function executeBucket(bucket, requestContext) {
      * 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,
             };
@@ -731,6 +733,9 @@ function executeBucket(bucket, requestContext) {
             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})!`);
@@ -753,7 +758,9 @@ function executeBucket(bucket, requestContext) {
             }
             const $sideEffect = step.implicitSideEffectStep;
             if ($sideEffect) {
-                addDependency($sideEffect, defaultForbiddenFlags, undefined);
+                if ($sideEffect._isUnary || !step._isUnary) {
+                    addDependency($sideEffect, defaultForbiddenFlags, undefined);
+                }
             }
             if (dev_js_1.isDev &&
                 step.layerPlan.reason.type === "polymorphic" &&
@@ -768,7 +775,7 @@ function executeBucket(bucket, requestContext) {
             }
             const result = needsFiltering
                 ? reallyExecuteStepWithFiltering(step, dependencies, _rawForbiddenFlags, _rawOnReject, bucket.polymorphicPathList, extra)
-                : reallyExecuteStepWithoutFiltering(step._isUnary ? 1 : size, step, $sideEffect ? dependencies.slice(0, depCount) : dependencies, extra);
+                : reallyExecuteStepWithoutFiltering(size, step, $sideEffect ? dependencies.slice(0, depCount) : dependencies, extra);
             if ((0, utils_js_1.isPromiseLike)(result)) {
                 return result.then(null, (error) => {
                     // Don't need to do this here, it will be done where the
@@ -804,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) {
@@ -828,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;
                 }
@@ -861,7 +872,6 @@ function executeBucket(bucket, requestContext) {
         }
     }
 }
-exports.executeBucket = executeBucket;
 /** @internal */
 function newBucket(spec, parentMetaByMetaKey) {
     if (dev_js_1.isDev) {
@@ -947,31 +957,60 @@ function newBucket(spec, parentMetaByMetaKey) {
         },
     };
 }
-exports.newBucket = newBucket;
 function bucketToString() {
     return `Bucket<${this.layerPlan}>`;
 }
-exports.bucketToString = bucketToString;
+// 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)) {
-    let cachedStateUnion = null;
     return {
-        at: batchEntriesAt,
+        // Try and keep these properties in the same order as unaryExecutionValue
         isBatch: true,
-        entries,
-        _flags,
+        at: batchEntriesAt,
+        unaryValue: batchThrowNotUnary,
         _flagsAt: batchFlagsAt,
-        _getStateUnion() {
-            if (cachedStateUnion === null) {
-                cachedStateUnion = _flags.reduce(bitwiseOr, interfaces_js_1.NO_FLAGS);
-            }
-            return cachedStateUnion;
-        },
+        _getStateUnion: batchGetStateUnion,
         _setResult: batchSetResult,
-        _copyResult,
+        _copyResult: batchCopyResult,
+        entries,
+        _flags,
+        _cachedStateUnion: null,
     };
 }
-exports.batchExecutionValue = batchExecutionValue;
+// 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];
 }
@@ -982,26 +1021,17 @@ function batchSetResult(i, value, flags) {
     this.entries[i] = value;
     this._flags[i] = flags;
 }
-function bitwiseOr(memo, a) {
-    return memo | a;
+// 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 _copyResult(targetIndex, source, sourceIndex) {
+function unaryCopyResult(targetIndex, source, sourceIndex) {
     this._setResult(targetIndex, source.at(sourceIndex), source._flagsAt(sourceIndex));
 }
-// TODO: memoize?
-function unaryExecutionValue(value, _entryFlags = 0) {
-    return {
-        at: unaryAt,
-        isBatch: false,
-        value,
-        _entryFlags,
-        _flagsAt: unaryFlagsAt,
-        _getStateUnion: unaryGetStateUnion,
-        _setResult: unarySetResult,
-        _copyResult,
-    };
+function unaryThisDotValue() {
+    return this.value;
 }
-exports.unaryExecutionValue = unaryExecutionValue;
 function unaryAt() {
     return this.value;
 }
@@ -1052,10 +1082,21 @@ function makeIndexForEach(count) {
     }
     return result;
 }
-function streamStepFromEvent(event) {
-    return event.step.stream(event.streamDetails);
-}
 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

package/dist/engine/executeOutputPlan.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.executeOutputPlan = void 0;
+exports.executeOutputPlan = executeOutputPlan;
 const tslib_1 = require("tslib");
 const debug_1 = tslib_1.__importDefault(require("debug"));
 const assert = tslib_1.__importStar(require("../assert.js"));
@@ -23,5 +23,4 @@ function executeOutputPlan(ctx, outputPlan, bucket, bucketIndex, outputDataAsStr
         ? outputPlan.executeString(ctx.root, mutablePath, bucket, bucketIndex)
         : outputPlan.execute(ctx.root, mutablePath, bucket, bucketIndex);
 }
-exports.executeOutputPlan = executeOutputPlan;
 //# sourceMappingURL=executeOutputPlan.js.map

package/dist/engine/lib/defaultPlanResolver.d.ts

@@ -0,0 +1,6 @@
+import type { FieldPlanResolver } from "../../interfaces.js";
+import type { Step } from "../../step.js";
+export declare const defaultPlanResolver: FieldPlanResolver<any, Step & {
+    get?: (field: string) => Step;
+}, any>;
+//# sourceMappingURL=defaultPlanResolver.d.ts.map

package/dist/engine/lib/defaultPlanResolver.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultPlanResolver = void 0;
+const access_js_1 = require("../../steps/access.js");
+const defaultPlanResolver = ($step, _, { fieldName }) => {
+    return typeof $step.get === "function"
+        ? $step.get(fieldName)
+        : (0, access_js_1.access)($step, [fieldName]);
+};
+exports.defaultPlanResolver = defaultPlanResolver;
+//# sourceMappingURL=defaultPlanResolver.js.map

package/dist/engine/lib/withGlobalLayerPlan.d.ts

@@ -1,7 +1,7 @@
-import type { ExecutableStep } from "../..";
+import type { Step } from "../..";
 import type { LayerPlan } from "../LayerPlan";
 export declare function withGlobalLayerPlan<T, TThis = any, TArgs extends [...args: any[]] = [...args: any[]]>(layerPlan: LayerPlan, polymorphicPaths: ReadonlySet<string> | null, callback: (this: TThis, ...args: TArgs) => T, callbackThis?: TThis, ...callbackArgs: TArgs): T;
 export declare function currentLayerPlan(): LayerPlan;
 export declare function currentPolymorphicPaths(): ReadonlySet<string> | null;
-export declare function isUnaryStep($step: ExecutableStep): boolean;
+export declare function isUnaryStep($step: Step): boolean;
 //# sourceMappingURL=withGlobalLayerPlan.d.ts.map

package/dist/engine/lib/withGlobalLayerPlan.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isUnaryStep = exports.currentPolymorphicPaths = exports.currentLayerPlan = exports.withGlobalLayerPlan = void 0;
+exports.withGlobalLayerPlan = withGlobalLayerPlan;
+exports.currentLayerPlan = currentLayerPlan;
+exports.currentPolymorphicPaths = currentPolymorphicPaths;
+exports.isUnaryStep = isUnaryStep;
 let globalData_layerPlan = undefined;
 let globalData_polymorphicPaths = undefined;
 function withGlobalLayerPlan(layerPlan, polymorphicPaths, callback, callbackThis, ...callbackArgs) {
@@ -16,7 +19,6 @@ function withGlobalLayerPlan(layerPlan, polymorphicPaths, callback, callbackThis
         globalData_polymorphicPaths = oldPolymorphicPaths;
     }
 }
-exports.withGlobalLayerPlan = withGlobalLayerPlan;
 function currentLayerPlan() {
     if (globalData_layerPlan === undefined) {
         throw new Error(
@@ -25,16 +27,13 @@ function currentLayerPlan() {
     }
     return globalData_layerPlan;
 }
-exports.currentLayerPlan = currentLayerPlan;
 function currentPolymorphicPaths() {
     if (globalData_polymorphicPaths === undefined) {
         throw new Error("GrafastInternalError<b0b05743-8b21-42c6-9b53-925013d88bd1>: currentPolymorphicPaths called out of turn; must only called within a withGlobalLayerPlan callback");
     }
     return globalData_polymorphicPaths;
 }
-exports.currentPolymorphicPaths = currentPolymorphicPaths;
 function isUnaryStep($step) {
     return $step._isUnary;
 }
-exports.isUnaryStep = isUnaryStep;
 //# sourceMappingURL=withGlobalLayerPlan.js.map

package/dist/engine/lock.d.ts

@@ -1,4 +1,4 @@
-import type { ExecutableStep } from "..";
-export declare function lock($step: ExecutableStep): void;
-export declare function unlock($step: ExecutableStep): boolean;
+import type { Step } from "..";
+export declare function lock($step: Step): void;
+export declare function unlock($step: Step): boolean;
 //# sourceMappingURL=lock.d.ts.map