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

package/dist/engine/OperationPlan.js

@@ -14,13 +14,15 @@ const inspect_js_1 = require("../inspect.js");
 const interfaces_js_1 = require("../interfaces.js");
 const operationPlan_input_js_1 = require("../operationPlan-input.js");
 const step_js_1 = require("../step.js");
-const access_js_1 = require("../steps/access.js");
+const connection_js_1 = require("../steps/connection.js");
 const constant_js_1 = require("../steps/constant.js");
 const graphqlResolver_js_1 = require("../steps/graphqlResolver.js");
 const timeSource_js_1 = require("../timeSource.js");
 const utils_js_1 = require("../utils.js");
 const LayerPlan_js_1 = require("./LayerPlan.js");
+const defaultPlanResolver_js_1 = require("./lib/defaultPlanResolver.js");
 const withGlobalLayerPlan_js_1 = require("./lib/withGlobalLayerPlan.js");
+const lock_js_1 = require("./lock.js");
 const OutputPlan_js_1 = require("./OutputPlan.js");
 const StepTracker_js_1 = require("./StepTracker.js");
 const atpe = typeof process !== "undefined" && process.env.ALWAYS_THROW_PLANNING_ERRORS;
@@ -49,22 +51,19 @@ const EMPTY_ARRAY = Object.freeze([]);
 exports.POLYMORPHIC_ROOT_PATH = null;
 exports.POLYMORPHIC_ROOT_PATHS = null;
 Object.freeze(exports.POLYMORPHIC_ROOT_PATHS);
-/** In development we might run additional checks */
-const isDev = typeof process !== "undefined" &&
-    (process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test");
 /** How many times will we try re-optimizing before giving up */
 const MAX_OPTIMIZATION_LOOPS = 10;
 const REASON_ROOT = Object.freeze({ type: "root" });
 const OUTPUT_PLAN_TYPE_NULL = Object.freeze({ mode: "null" });
 const OUTPUT_PLAN_TYPE_ARRAY = Object.freeze({ mode: "array" });
-const newValueStepCallback = () => new index_js_1.__ValueStep();
+const newValueStepCallback = (isImmutable) => new index_js_1.__ValueStep(isImmutable);
 const NO_ARGS = {
     get() {
         throw new Error(`This field doesn't have any arguments`);
     },
 };
 class OperationPlan {
-    constructor(schema, operation, fragments, variableValues, context, rootValue, planningTimeout) {
+    constructor(schema, operation, fragments, variableValuesConstraints, variableValues, contextConstraints, context, rootValueConstraints, rootValue, planningTimeout) {
         this.schema = schema;
         this.operation = operation;
         this.fragments = fragments;
@@ -83,29 +82,16 @@ class OperationPlan {
          * 7. ready
          *
          * Once in 'ready' state we can execute the plan.
-         *
-         * @internal
          */
         this.phase = "init";
         /**
          * Gets updated as we work our way through the plan, useful for making errors more helpful.
          */
-        this.loc = isDev
+        this.loc = index_js_1.isDev
             ? []
             : null /* forbid loc in production */;
-        this.modifierStepCount = 0;
-        this.modifierDepthCount = 0;
-        this.modifierSteps = [];
         /** @internal */
         this.stepTracker = new StepTracker_js_1.StepTracker(this);
-        this.maxDeduplicatedStepId = -1;
-        this.maxValidatedStepId = -1;
-        /** Constraints based on evaluating variables. @internal */
-        this.variableValuesConstraints = [];
-        /** Constraints based on evaluating context. @internal */
-        this.contextConstraints = [];
-        /** Constraints based on evaluating rootValue. @internal */
-        this.rootValueConstraints = [];
         /**
          * @internal
          */
@@ -118,8 +104,10 @@ class OperationPlan {
         this.previousLap = this.startTime;
         this.laps = [];
         this.optimizeMeta = new Map();
+        /** @internal */
+        this.valueNodeToStaticValueCache = new Map();
         /** @internal Use plan.getStep(id) instead. */
-        this.getStep = isDev
+        this.getStep = index_js_1.isDev
             ? (id, requestingStep) => {
                 if (!["plan", "validate", "optimize"].includes(this.phase)) {
                     throw new Error(`Getting a step during the '${this.phase}' phase is forbidden - please do so before or during the optimize phase.`);
@@ -141,6 +129,10 @@ class OperationPlan {
                 return step[interfaces_js_1.$$proxy] ?? step;
             };
         this.polymorphicLayerPlanByPathByLayerPlan = new Map();
+        this._cacheStepStoreByLayerPlanAndActionKey = Object.create(null);
+        this.variableValuesConstraints = variableValuesConstraints;
+        this.contextConstraints = contextConstraints;
+        this.rootValueConstraints = rootValueConstraints;
         this.scalarPlanInfo = { schema: this.schema };
         const queryType = schema.getQueryType();
         assert.ok(queryType, "Schema must have a query type");
@@ -174,10 +166,6 @@ class OperationPlan {
         this.operationType = operation.operation;
         this.phase = "plan";
         this.rootLayerPlan = new LayerPlan_js_1.LayerPlan(this, null, REASON_ROOT);
-        // This doesn't do anything, it only exists to align plans more closely
-        // with an older version of the planner (to reduce the diff).
-        const rootSelectionSetStep = (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(this.rootLayerPlan, exports.POLYMORPHIC_ROOT_PATHS, newValueStepCallback);
-        this.rootLayerPlan.setRootStep(rootSelectionSetStep);
         // Set up the shared steps for variables, context and rootValue
         [this.variableValuesStep, this.trackedVariableValuesStep] = this.track(variableValues, this.variableValuesConstraints, this.operation.variableDefinitions);
         [this.contextStep, this.trackedContextStep] = this.track(context, this.contextConstraints);
@@ -193,13 +181,15 @@ class OperationPlan {
         this.hoistSteps();
         this.checkTimeout();
         this.lap("hoistSteps", "planOperation");
-        if (isDev) {
+        if (index_js_1.isDev) {
             this.phase = "validate";
+            this.resetCache();
             // Helpfully check steps don't do forbidden things.
             this.validateSteps();
             this.lap("validateSteps");
         }
         this.phase = "optimize";
+        this.resetCache();
         // Get rid of temporary steps before `optimize` triggers side-effects.
         // (Critical due to steps that may have been discarded due to field errors
         // or similar.)
@@ -212,7 +202,11 @@ class OperationPlan {
         });
         this.checkTimeout();
         this.lap("optimizeSteps");
+        this.inlineSteps();
+        this.checkTimeout();
+        this.lap("inlineSteps");
         this.phase = "finalize";
+        this.resetCache();
         this.stepTracker.finalizeSteps();
         // Get rid of steps that are no longer needed after optimising outputPlans
         // (we shouldn't see any new steps or dependencies after here)
@@ -249,6 +243,7 @@ class OperationPlan {
         });
         this.lap("finalizeOutputPlans");
         this.phase = "ready";
+        this.resetCache();
         // this.walkFinalizedPlans();
         // this.preparePrefetches();
         const allMetaKeys = new Set();
@@ -323,21 +318,6 @@ class OperationPlan {
         }
         return this.stepTracker.addStep(plan);
     }
-    /**
-     * Adds a plan to the known steps and returns the number to use as the plan
-     * id. ONLY to be used from Step, user code should never call this directly.
-     *
-     * @internal
-     */
-    _addModifierStep(step) {
-        if (!["plan", "validate", "optimize"].includes(this.phase)) {
-            throw new Error(`Creating a step during the '${this.phase}' phase is forbidden.`);
-        }
-        const modifierStepId = `${this.modifierDepthCount}-${this
-            .modifierStepCount++}`;
-        this.modifierSteps.push(step);
-        return modifierStepId;
-    }
     /**
      * Get a plan without specifying who requested it; this disables all the
      * caller checks. Only intended to be called from internal code.
@@ -400,7 +380,7 @@ class OperationPlan {
             typeName: this.queryType.name,
         }, locationDetails);
         this.rootOutputPlan = outputPlan;
-        this.planSelectionSet(outputPlan, [], exports.POLYMORPHIC_ROOT_PATH, exports.POLYMORPHIC_ROOT_PATHS, this.trackedRootValueStep, rootType, this.operation.selectionSet.selections);
+        this.planSelectionSet(outputPlan, [], exports.POLYMORPHIC_ROOT_PATH, exports.POLYMORPHIC_ROOT_PATHS, this.trackedRootValueStep, rootType, this.operation.selectionSet.selections, true);
         if (this.loc !== null)
             this.loc.pop();
     }
@@ -426,7 +406,7 @@ class OperationPlan {
             typeName: rootType.name,
         }, locationDetails);
         this.rootOutputPlan = outputPlan;
-        this.planSelectionSet(outputPlan, [], exports.POLYMORPHIC_ROOT_PATH, exports.POLYMORPHIC_ROOT_PATHS, this.trackedRootValueStep, rootType, this.operation.selectionSet.selections, true);
+        this.planSelectionSet(outputPlan, [], exports.POLYMORPHIC_ROOT_PATH, exports.POLYMORPHIC_ROOT_PATHS, this.trackedRootValueStep, rootType, this.operation.selectionSet.selections, true, true);
         if (this.loc !== null)
             this.loc.pop();
     }
@@ -441,7 +421,7 @@ class OperationPlan {
             throw new index_js_1.SafeError("No subscription type found in schema");
         }
         const selectionSet = this.operation.selectionSet;
-        const groupedFieldSet = (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(this.rootLayerPlan, exports.POLYMORPHIC_ROOT_PATHS, graphqlCollectFields_js_1.graphqlCollectFields, null, this, this.trackedRootValueStep.id, rootType, selectionSet.selections);
+        const groupedFieldSet = (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(this.rootLayerPlan, exports.POLYMORPHIC_ROOT_PATHS, graphqlCollectFields_js_1.graphqlCollectFields, null, this, this.trackedRootValueStep.id, rootType, selectionSet.selections, (0, graphqlCollectFields_js_1.newSelectionSetDigest)(false));
         if (groupedFieldSet.deferred !== undefined) {
             throw new index_js_1.SafeError("@defer forbidden on subscription root selection set");
         }
@@ -476,14 +456,10 @@ class OperationPlan {
             : NO_ARGS;
         if (subscriptionPlanResolver !== undefined) {
             // PERF: optimize this
-            const { haltTree, step: subscribeStep } = this.planField(this.rootLayerPlan, path, exports.POLYMORPHIC_ROOT_PATHS, fields, subscriptionPlanResolver, "autoApplyAfterParentSubscribePlan", this.trackedRootValueStep, fieldSpec, trackedArguments);
+            const { haltTree, step: subscribeStep } = this.planField(rootType.name, fieldName, this.rootLayerPlan, path, exports.POLYMORPHIC_ROOT_PATHS, subscriptionPlanResolver, "subscribePlan", this.trackedRootValueStep, fieldSpec, trackedArguments, true);
             if (haltTree) {
                 throw new index_js_1.SafeError("Failed to setup subscription");
             }
-            const stepOptions = {
-                stream: { initialCount: 0 },
-            };
-            subscribeStep._stepOptions = stepOptions;
             this.rootLayerPlan.setRootStep(subscribeStep);
             const subscriptionEventLayerPlan = new LayerPlan_js_1.LayerPlan(this, this.rootLayerPlan, {
                 type: "subscription",
@@ -498,7 +474,7 @@ class OperationPlan {
             streamItemPlan = this.stepTracker.getStepById(streamItemPlan.id);
             const outputPlan = new OutputPlan_js_1.OutputPlan(subscriptionEventLayerPlan, this.rootValueStep, { mode: "root", typeName: rootType.name }, locationDetails);
             this.rootOutputPlan = outputPlan;
-            this.planSelectionSet(outputPlan, [], exports.POLYMORPHIC_ROOT_PATH, exports.POLYMORPHIC_ROOT_PATHS, streamItemPlan, rootType, selectionSet.selections);
+            this.planSelectionSet(outputPlan, [], exports.POLYMORPHIC_ROOT_PATH, exports.POLYMORPHIC_ROOT_PATHS, streamItemPlan, rootType, selectionSet.selections, false);
         }
         else {
             const subscribeStep = (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(this.rootLayerPlan, exports.POLYMORPHIC_ROOT_PATHS, () => {
@@ -524,10 +500,8 @@ class OperationPlan {
                     },
                 });
             });
-            const stepOptions = {
-                stream: { initialCount: 0 },
-            };
-            subscribeStep._stepOptions = stepOptions;
+            subscribeStep._stepOptions.stream = {};
+            subscribeStep._stepOptions.walkIterable = true;
             this.rootLayerPlan.setRootStep(subscribeStep);
             const subscriptionEventLayerPlan = new LayerPlan_js_1.LayerPlan(this, this.rootLayerPlan, {
                 type: "subscription",
@@ -542,7 +516,7 @@ class OperationPlan {
             streamItemPlan = this.stepTracker.getStepById(streamItemPlan.id);
             const outputPlan = new OutputPlan_js_1.OutputPlan(subscriptionEventLayerPlan, this.rootValueStep, { mode: "root", typeName: rootType.name }, locationDetails);
             this.rootOutputPlan = outputPlan;
-            this.planSelectionSet(outputPlan, [], exports.POLYMORPHIC_ROOT_PATH, exports.POLYMORPHIC_ROOT_PATHS, streamItemPlan, rootType, selectionSet.selections);
+            this.planSelectionSet(outputPlan, [], exports.POLYMORPHIC_ROOT_PATH, exports.POLYMORPHIC_ROOT_PATHS, streamItemPlan, rootType, selectionSet.selections, true);
         }
         if (this.loc !== null)
             this.loc.pop();
@@ -551,7 +525,7 @@ class OperationPlan {
      * Gets the item plan for a given parent list plan - this ensures we only
      * create one item plan per parent plan.
      */
-    itemStepForListStep(parentLayerPlan, listStep, depth = 0) {
+    itemStepForListStep(parentLayerPlan, listStep, depth, stream) {
         const itemStepId = this.itemStepIdByListStepId[listStep.id];
         if (itemStepId !== undefined) {
             return this.stepTracker.getStepById(itemStepId);
@@ -560,7 +534,7 @@ class OperationPlan {
         const layerPlan = new LayerPlan_js_1.LayerPlan(this, parentLayerPlan, {
             type: "listItem",
             parentStep: listStep,
-            stream: listStep._stepOptions.stream ?? undefined,
+            stream,
         });
         const itemPlan = (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(layerPlan, listStep.polymorphicPaths, () => new index_js_1.__ItemStep(listStep, depth));
         layerPlan.setRootStep(itemPlan);
@@ -572,187 +546,246 @@ class OperationPlan {
     outputPlan, path, polymorphicPath, polymorphicPaths, parentStep, objectType, objectTypeFields, isMutation, groupedFieldSet) {
         // `__typename` shouldn't bump the mutation index since it has no side effects.
         let mutationIndex = -1;
+        const $sideEffect = outputPlan.layerPlan.latestSideEffectStep;
         for (const [responseKey, fieldNodes] of groupedFieldSet.fields.entries()) {
-            // All grouped fields are equivalent, as mandated by GraphQL validation rules. Thus we can take the first one.
-            const field = fieldNodes[0];
-            const fieldName = field.name.value;
-            const locationDetails = {
-                parentTypeName: objectType.name,
-                fieldName,
-                node: fieldNodes,
-            };
-            // explicit matches are the fastest: https://jsben.ch/ajZNf
-            if (fieldName === "__typename") {
-                outputPlan.addChild(objectType, responseKey, {
-                    type: "__typename",
-                    locationDetails,
-                });
-                continue;
-            }
-            else if (fieldName === "__schema" || fieldName === "__type") {
-                const variableNames = (0, utils_js_1.findVariableNamesUsed)(this, field);
-                outputPlan.addChild(objectType, responseKey, {
-                    type: "outputPlan",
-                    isNonNull: fieldName === "__schema",
-                    outputPlan: new OutputPlan_js_1.OutputPlan(outputPlan.layerPlan, this.rootValueStep, {
-                        mode: "introspection",
-                        field,
-                        variableNames,
-                        // PERF: if variableNames.length === 0 we should be able to optimize this!
-                        introspectionCacheByVariableValues: new lru_1.default({
-                            maxLength: 3,
-                        }),
-                    }, locationDetails),
-                    locationDetails,
-                });
-                continue;
-            }
-            const objectField = objectTypeFields[fieldName];
-            if (!objectField) {
-                // Field does not exist; this should have been caught by validation
-                // but the spec says to just skip it.
-                continue;
-            }
-            const fieldType = objectField.type;
-            const rawPlanResolver = objectField.extensions?.grafast?.plan;
-            if (rawPlanResolver?.constructor?.name === "AsyncFunction") {
-                throw new Error(`Plans must be synchronous, but this schema has an async function at '${objectType.name}.${fieldName}.plan': ${rawPlanResolver.toString()}`);
-            }
-            const namedReturnType = getNamedType(fieldType);
-            const resolvedResolver = objectField.resolve;
-            const subscriber = objectField.subscribe;
-            const usesDefaultResolver = resolvedResolver == null || resolvedResolver === defaultFieldResolver;
-            const resolver = usesDefaultResolver ? null : resolvedResolver;
-            // Apply a default plan to fields that do not have a plan nor a resolver.
-            const planResolver = rawPlanResolver ??
-                (usesDefaultResolver ? makeDefaultPlan(fieldName) : undefined);
-            /*
-             *  When considering resolvers on fields, there's three booleans to
-             *  consider:
-             *
-             *  - typeIsPlanned: Does the type the field is defined on expect a plan?
-             *    - NOTE: the root types (Query, Mutation, Subscription) implicitly
-             *      expect the "root plan"
-             *  - fieldHasPlan: Does the field define a `plan()` method?
-             *  - resultIsPlanned: Does the named type that the field returns (the
-             *    "named field type") expect a plan?
-             *    - NOTE: only object types, unions and interfaces may expect plans;
-             *      but not all of them do.
-             *    - NOTE: a union/interface expects a plan iff ANY of its object
-             *      types expect plans
-             *    - NOTE: if ANY object type in an interface/union expects a plan
-             *      then ALL object types within the interface/union must expect
-             *      plans.
-             *    - NOTE: scalars and enums never expect a plan.
-             *
-             *  These booleans impact:
-             *
-             *  - Whether there must be a `plan()` declaration and what the "parent"
-             *    argument is to the same
-             *    - If typeIsPlanned:
-             *      - Assert: `fieldHasPlan` must be true
-             *      - Pass through the parent plan
-             *    - Else, if resultIsPlanned:
-             *      - Assert: `fieldHasPlan` must be true
-             *      - Pass through a `__ValueStep` representing the parent value.
-             *    - Else, if fieldHasPlan:
-             *      - Pass through a `__ValueStep` representing the parent value.
-             *    - Else
-             *      - No action necessary.
-             *  - If the field may define `resolve()` and what the "parent" argument
-             *    is to the same
-             *    - If resultIsPlanned
-             *      - Assert: there must not be a `resolve()`
-             *      - Grafast provides pure resolver.
-             *    - Else if fieldHasPlan (which may be implied by typeIsPlanned
-             *      above)
-             *      - If `resolve()` is not set:
-             *        - grafast will return the value from the plan directly
-             *      - Otherwise:
-             *        - Grafast will wrap this resolver and will call `resolve()` (or
-             *          default resolver) with the plan result.  IMPORTANT: you may
-             *          want to use an `ObjectStep` so that the parent object is of
-             *          the expected shape; e.g. your plan might return
-             *          `object({username: $username})` for a `User.username` field.
-             *    - Else
-             *      - Leave `resolve()` untouched - do not even wrap it.
-             *      - (Failing that, use a __ValueStep and return the result
-             *        directly.)
-             */
-            if (resolver !== null) {
-                this.pure = false;
-            }
-            const resultIsPlanned = (0, utils_js_1.isTypePlanned)(this.schema, namedReturnType);
-            const fieldHasPlan = !!planResolver;
-            if (resultIsPlanned &&
-                !fieldHasPlan &&
-                !objectType.extensions?.grafast?.assertStep) {
-                throw new Error(`Field ${objectType.name}.${fieldName} returns a ${namedReturnType.name} which expects a plan to be available; however this field has no plan() method to produce such a plan; please add 'extensions.grafast.plan' to this field.`);
-            }
-            if (resultIsPlanned && resolver) {
-                throw new Error(`Field ${objectType.name}.${fieldName} returns a ${namedReturnType.name} which expects a plan to be available; this means that ${objectType.name}.${fieldName} is forbidden from defining a GraphQL resolver.`);
-            }
-            let step;
-            let haltTree = false;
-            const fieldLayerPlan = isMutation
-                ? new LayerPlan_js_1.LayerPlan(this, outputPlan.layerPlan, {
-                    type: "mutationField",
-                    mutationIndex: ++mutationIndex,
-                })
-                : outputPlan.layerPlan;
-            const objectFieldArgs = objectField.args;
-            const trackedArguments = objectFieldArgs.length > 0
-                ? (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(this.rootLayerPlan, exports.POLYMORPHIC_ROOT_PATHS, this.getTrackedArguments, this, objectFieldArgs, field)
-                : NO_ARGS;
-            const fieldPath = [...path, responseKey];
-            if (typeof planResolver === "function") {
-                ({ step, haltTree } = this.planField(fieldLayerPlan, fieldPath, polymorphicPaths, fieldNodes, planResolver, "autoApplyAfterParentPlan", parentStep, objectField, trackedArguments));
-            }
-            else {
-                // No plan resolver (or plan resolver fallback) so there must be a
-                // `resolve` method, so we'll feed the full parent step into the
-                // resolver.
-                assert.ok(resolver !== null, "GraphileInternalError<81652257-617a-4d1a-8306-903d0e3d2ddf>: The field has no resolver, so planResolver should exist (either as the field.plan or as the default plan resolver).");
-                // ENHANCEMENT: should we do `step = parentStep.object()` (i.e.
-                // `$pgSelectSingle.record()`) or similar for "opaque" steps to become
-                // suitable for consumption by resolvers?
-                // Maybe `parentStep.forResolver()` or `parentStep.hydrate()` or `parentStep.toFullObject()`?
-                step = parentStep;
-            }
-            if (resolver !== null) {
-                step = (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(fieldLayerPlan, polymorphicPaths, () => {
-                    const $args = (0, index_js_1.object)(field.arguments?.reduce((memo, arg) => {
-                        memo[arg.name.value] = trackedArguments.get(arg.name.value);
-                        return memo;
-                    }, Object.create(null)) ?? Object.create(null));
-                    return (0, graphqlResolver_js_1.graphqlResolver)(resolver, subscriber, step, $args, {
-                        fieldName,
-                        fieldNodes,
-                        fragments: this.fragments,
-                        operation: this.operation,
-                        parentType: objectType,
-                        returnType: fieldType,
-                        schema: this.schema,
+            let resolverEmulation = groupedFieldSet.resolverEmulation;
+            try {
+                // All grouped fields are equivalent, as mandated by GraphQL validation rules. Thus we can take the first one.
+                const field = fieldNodes[0];
+                const fieldName = field.name.value;
+                const locationDetails = {
+                    parentTypeName: objectType.name,
+                    fieldName,
+                    node: fieldNodes,
+                };
+                // explicit matches are the fastest: https://jsben.ch/ajZNf
+                if (fieldName === "__typename") {
+                    outputPlan.addChild(objectType, responseKey, {
+                        type: "__typename",
+                        locationDetails,
                     });
-                });
-            }
-            // May have changed due to deduplicate
-            step = this.stepTracker.getStepById(step.id);
-            if (haltTree) {
-                const isNonNull = isNonNullType(fieldType);
-                outputPlan.addChild(objectType, responseKey, {
-                    type: "outputPlan",
-                    outputPlan: new OutputPlan_js_1.OutputPlan(fieldLayerPlan, step, OUTPUT_PLAN_TYPE_NULL, locationDetails),
-                    isNonNull,
-                    locationDetails,
-                });
+                    continue;
+                }
+                else if (fieldName === "__schema" || fieldName === "__type") {
+                    const variableNames = (0, utils_js_1.findVariableNamesUsed)(this, field);
+                    outputPlan.addChild(objectType, responseKey, {
+                        type: "outputPlan",
+                        isNonNull: fieldName === "__schema",
+                        outputPlan: new OutputPlan_js_1.OutputPlan(outputPlan.layerPlan, this.rootValueStep, {
+                            mode: "introspection",
+                            field,
+                            variableNames,
+                            // PERF: if variableNames.length === 0 we should be able to optimize this!
+                            introspectionCacheByVariableValues: new lru_1.default({
+                                maxLength: 3,
+                            }),
+                        }, locationDetails),
+                        locationDetails,
+                    });
+                    continue;
+                }
+                const objectField = objectTypeFields[fieldName];
+                if (!objectField) {
+                    // Field does not exist; this should have been caught by validation
+                    // but the spec says to just skip it.
+                    continue;
+                }
+                const fieldType = objectField.type;
+                const rawPlanResolver = objectField.extensions?.grafast?.plan;
+                if (rawPlanResolver) {
+                    resolverEmulation = false;
+                    (0, utils_js_1.assertNotAsync)(rawPlanResolver, `${objectType.name}.${fieldName}.plan`);
+                }
+                const namedReturnType = getNamedType(fieldType);
+                const resolvedResolver = objectField.resolve;
+                const subscriber = objectField.subscribe;
+                const usesDefaultResolver = resolvedResolver == null || resolvedResolver === defaultFieldResolver;
+                const isPolymorphic = isUnionType(namedReturnType) || isInterfaceType(namedReturnType);
+                // We should use a resolver if:
+                // 1. they give us a non-default resolver
+                // 2. we're emulating resolvers AND the field is polymorphic
+                const resolver = resolvedResolver && !usesDefaultResolver
+                    ? resolvedResolver
+                    : resolverEmulation && isPolymorphic
+                        ? defaultFieldResolver
+                        : null;
+                // Apply a default plan to fields that do not have a plan nor a resolver.
+                const planResolver = rawPlanResolver ?? (resolver ? undefined : defaultPlanResolver_js_1.defaultPlanResolver);
+                /*
+                 *  When considering resolvers on fields, there's three booleans to
+                 *  consider:
+                 *
+                 *  - typeIsPlanned: Does the type the field is defined on expect a plan?
+                 *    - NOTE: the root types (Query, Mutation, Subscription) implicitly
+                 *      expect the "root plan"
+                 *  - fieldHasPlan: Does the field define a `plan()` method?
+                 *  - resultIsPlanned: Does the named type that the field returns (the
+                 *    "named field type") expect a plan?
+                 *    - NOTE: only object types, unions and interfaces may expect plans;
+                 *      but not all of them do.
+                 *    - NOTE: a union/interface expects a plan iff ANY of its object
+                 *      types expect plans
+                 *    - NOTE: if ANY object type in an interface/union expects a plan
+                 *      then ALL object types within the interface/union must expect
+                 *      plans.
+                 *    - NOTE: scalars and enums never expect a plan.
+                 *
+                 *  These booleans impact:
+                 *
+                 *  - Whether there must be a `plan()` declaration and what the "parent"
+                 *    argument is to the same
+                 *    - If typeIsPlanned:
+                 *      - Assert: `fieldHasPlan` must be true
+                 *      - Pass through the parent plan
+                 *    - Else, if resultIsPlanned:
+                 *      - Assert: `fieldHasPlan` must be true
+                 *      - Pass through a `__ValueStep` representing the parent value.
+                 *    - Else, if fieldHasPlan:
+                 *      - Pass through a `__ValueStep` representing the parent value.
+                 *    - Else
+                 *      - No action necessary.
+                 *  - If the field may define `resolve()` and what the "parent" argument
+                 *    is to the same
+                 *    - If resultIsPlanned
+                 *      - Assert: there must not be a `resolve()`
+                 *      - Grafast provides pure resolver.
+                 *    - Else if fieldHasPlan (which may be implied by typeIsPlanned
+                 *      above)
+                 *      - If `resolve()` is not set:
+                 *        - grafast will return the value from the plan directly
+                 *      - Otherwise:
+                 *        - Grafast will wrap this resolver and will call `resolve()` (or
+                 *          default resolver) with the plan result.  IMPORTANT: you may
+                 *          want to use an `ObjectStep` so that the parent object is of
+                 *          the expected shape; e.g. your plan might return
+                 *          `object({username: $username})` for a `User.username` field.
+                 *    - Else
+                 *      - Leave `resolve()` untouched - do not even wrap it.
+                 *      - (Failing that, use a __ValueStep and return the result
+                 *        directly.)
+                 */
+                if (resolver !== null) {
+                    this.pure = false;
+                    if (!rawPlanResolver) {
+                        resolverEmulation = true;
+                    }
+                }
+                const resultIsPlanned = (0, utils_js_1.isTypePlanned)(this.schema, namedReturnType);
+                const fieldHasPlan = !!planResolver;
+                if (resultIsPlanned &&
+                    !fieldHasPlan &&
+                    !objectType.extensions?.grafast?.assertStep) {
+                    throw new Error(`Field ${objectType.name}.${fieldName} returns a ${namedReturnType.name} which expects a plan to be available; however this field has no plan() method to produce such a plan; please add 'extensions.grafast.plan' to this field.`);
+                }
+                if (resultIsPlanned && resolver) {
+                    throw new Error(`Field ${objectType.name}.${fieldName} returns a ${namedReturnType.name} which expects a plan to be available; this means that ${objectType.name}.${fieldName} is forbidden from defining a GraphQL resolver.`);
+                }
+                let step;
+                let haltTree = false;
+                const fieldLayerPlan = isMutation
+                    ? new LayerPlan_js_1.LayerPlan(this, outputPlan.layerPlan, {
+                        type: "mutationField",
+                        mutationIndex: ++mutationIndex,
+                    })
+                    : outputPlan.layerPlan;
+                const objectFieldArgs = objectField.args;
+                const trackedArguments = objectFieldArgs.length > 0
+                    ? (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(this.rootLayerPlan, exports.POLYMORPHIC_ROOT_PATHS, this.getTrackedArguments, this, objectFieldArgs, field)
+                    : NO_ARGS;
+                const fieldPath = [...path, responseKey];
+                let streamDetails = null;
+                const isList = isListType(getNullableType(fieldType));
+                if (isList) {
+                    // read the @stream directive, if present
+                    // TODO: Check SameStreamDirective still exists in @stream spec at release.
+                    /*
+                     * `SameStreamDirective`
+                     * (https://github.com/graphql/graphql-spec/blob/26fd78c4a89a79552dcc0c7e0140a975ce654400/spec/Section%205%20--%20Validation.md#L450-L458)
+                     * ensures that every field that has `@stream` must have the same
+                     * `@stream` arguments; so we can just check the first node in the
+                     * merged set to see our stream options. NOTE: if this changes before
+                     * release then we may need to find the stream with the largest
+                     * `initialCount` to figure what to do; something like:
+                     *
+                     *      const streamDirective = firstField.directives?.filter(
+                     *        (d) => d.name.value === "stream",
+                     *      ).sort(
+                     *        (a, z) => getArg(z, 'initialCount', 0) - getArg(a, 'initialCount', 0)
+                     *      )[0]
+                     */
+                    for (const n of fieldNodes) {
+                        const streamDirective = n.directives?.find((d) => d.name.value === "stream");
+                        if (streamDirective === undefined) {
+                            // Undo any previous stream details; the non-@stream wins.
+                            streamDetails = null;
+                            break;
+                        }
+                        else if (streamDetails !== null) {
+                            // Validation promises the values are the same
+                            continue;
+                        }
+                        else {
+                            // Create streamDetails
+                            streamDetails = this.withRootLayerPlan(() => ({
+                                initialCount: this.internalDependency((0, utils_js_1.directiveArgument)(this, streamDirective, "initialCount", graphql.Kind.INT) ?? (0, constant_js_1.constant)(0)),
+                                if: this.internalDependency((0, utils_js_1.directiveArgument)(this, streamDirective, "if", graphql.Kind.BOOLEAN) ?? (0, constant_js_1.constant)(true)),
+                                label: this.internalDependency((0, utils_js_1.directiveArgument)(this, streamDirective, "label", graphql.Kind.STRING) ?? (0, constant_js_1.constant)(undefined)),
+                            }));
+                        }
+                    }
+                }
+                if (typeof planResolver === "function") {
+                    ({ step, haltTree } = this.planField(objectType.name, fieldName, fieldLayerPlan, fieldPath, polymorphicPaths, planResolver, "plan", parentStep, objectField, trackedArguments, isList ? (streamDetails ?? false) : null));
+                }
+                else {
+                    // No plan resolver (or plan resolver fallback) so there must be a
+                    // `resolve` method, so we'll feed the full parent step into the
+                    // resolver.
+                    assert.ok(resolver !== null, "GraphileInternalError<81652257-617a-4d1a-8306-903d0e3d2ddf>: The field has no resolver, so planResolver should exist (either as the field.plan or as the default plan resolver).");
+                    // ENHANCEMENT: should we do `step = parentStep.object()` (i.e.
+                    // `$pgSelectSingle.record()`) or similar for "opaque" steps to become
+                    // suitable for consumption by resolvers?
+                    // Maybe `parentStep.forResolver()` or `parentStep.hydrate()` or `parentStep.toFullObject()`?
+                    step = parentStep;
+                }
+                if (resolver !== null) {
+                    step = (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(fieldLayerPlan, polymorphicPaths, () => {
+                        const $args = (0, index_js_1.object)(field.arguments?.reduce((memo, arg) => {
+                            memo[arg.name.value] = trackedArguments.get(arg.name.value);
+                            return memo;
+                        }, Object.create(null)) ?? Object.create(null));
+                        return (0, graphqlResolver_js_1.graphqlResolver)(resolver, subscriber, step, $args, {
+                            fieldName,
+                            fieldNodes,
+                            fragments: this.fragments,
+                            operation: this.operation,
+                            parentType: objectType,
+                            returnType: fieldType,
+                            schema: this.schema,
+                        });
+                    });
+                }
+                // May have changed due to deduplicate
+                step = this.stepTracker.getStepById(step.id);
+                if (haltTree) {
+                    const isNonNull = isNonNullType(fieldType);
+                    outputPlan.addChild(objectType, responseKey, {
+                        type: "outputPlan",
+                        outputPlan: new OutputPlan_js_1.OutputPlan(fieldLayerPlan, step, OUTPUT_PLAN_TYPE_NULL, locationDetails),
+                        isNonNull,
+                        locationDetails,
+                    });
+                }
+                else {
+                    this.planIntoOutputPlan(outputPlan, fieldLayerPlan, fieldPath, polymorphicPath, polymorphicPaths, 
+                    // If one field has a selection set, they all have a selection set (guaranteed by validation).
+                    field.selectionSet != null
+                        ? fieldNodes.flatMap((n) => n.selectionSet.selections)
+                        : undefined, objectType, responseKey, fieldType, step, locationDetails, resolverEmulation, 0, streamDetails);
+                }
             }
-            else {
-                this.planIntoOutputPlan(outputPlan, fieldLayerPlan, fieldPath, polymorphicPath, polymorphicPaths, 
-                // If one field has a selection set, they all have a selection set (guaranteed by validation).
-                field.selectionSet != null
-                    ? fieldNodes.flatMap((n) => n.selectionSet.selections)
-                    : undefined, objectType, responseKey, fieldType, step, locationDetails);
+            finally {
+                outputPlan.layerPlan.latestSideEffectStep = $sideEffect;
             }
         }
         if (groupedFieldSet.deferred !== undefined) {
@@ -769,8 +802,14 @@ class OperationPlan {
                 // LOGGING: the location details should be tweaked to reference this
                 // fragment
                 outputPlan.locationDetails);
-                outputPlan.deferredOutputPlans.push(deferredOutputPlan);
-                this.processGroupedFieldSet(deferredOutputPlan, path, polymorphicPath, polymorphicPaths, parentStep, objectType, objectTypeFields, isMutation, deferred);
+                const $sideEffect = deferredOutputPlan.layerPlan.latestSideEffectStep;
+                try {
+                    outputPlan.deferredOutputPlans.push(deferredOutputPlan);
+                    this.processGroupedFieldSet(deferredOutputPlan, path, polymorphicPath, polymorphicPaths, parentStep, objectType, objectTypeFields, isMutation, deferred);
+                }
+                finally {
+                    deferredOutputPlan.layerPlan.latestSideEffectStep = $sideEffect;
+                }
             }
         }
     }
@@ -783,80 +822,122 @@ class OperationPlan {
      * @param selections - The GraphQL selections (fields, fragment spreads, inline fragments) to evaluate
      * @param isMutation - If true this selection set should be executed serially rather than in parallel (each field gets its own LayerPlan)
      */
-    planSelectionSet(outputPlan, path, polymorphicPath, polymorphicPaths, parentStep, objectType, selections, isMutation = false) {
+    planSelectionSet(outputPlan, path, polymorphicPath, polymorphicPaths, parentStep, objectType, selections, resolverEmulation, isMutation = false) {
         if (this.loc !== null) {
             this.loc.push(`planSelectionSet(${objectType.name} @ ${outputPlan.layerPlan.id} @ ${path.join(".")} @ ${polymorphicPath ?? ""})`);
         }
-        if (isDev) {
+        if (index_js_1.isDev) {
             assertObjectType(objectType);
         }
-        const groupedFieldSet = (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(outputPlan.layerPlan, polymorphicPaths, graphqlCollectFields_js_1.graphqlCollectFields, null, this, parentStep.id, objectType, selections, isMutation);
+        const groupedFieldSet = (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(outputPlan.layerPlan, polymorphicPaths, graphqlCollectFields_js_1.graphqlCollectFields, null, this, parentStep.id, objectType, selections, (0, graphqlCollectFields_js_1.newSelectionSetDigest)(resolverEmulation), isMutation);
         const objectTypeFields = objectType.getFields();
         this.processGroupedFieldSet(outputPlan, path, polymorphicPath, polymorphicPaths, parentStep, objectType, objectTypeFields, isMutation, groupedFieldSet);
         if (this.loc !== null)
             this.loc.pop();
     }
+    internalDependency($step) {
+        this.stepTracker.internalDependencies.add($step);
+        return $step;
+    }
     // Similar to the old 'planFieldReturnType'
     planIntoOutputPlan(parentOutputPlan, 
     // Typically this is parentOutputPlan.layerPlan; but in the case of mutationFields it isn't.
     parentLayerPlan, 
     // This is the LAYER-RELATIVE path, not the absolute path! It resets!
-    path, polymorphicPath, polymorphicPaths, selections, parentObjectType, responseKey, fieldType, $step, locationDetails, listDepth = 0) {
+    path, polymorphicPath, polymorphicPaths, selections, parentObjectType, responseKey, fieldType, $step, locationDetails, resolverEmulation, listDepth, streamDetails) {
         const nullableFieldType = getNullableType(fieldType);
         const isNonNull = nullableFieldType !== fieldType;
         if (isListType(nullableFieldType)) {
-            const listOutputPlan = new OutputPlan_js_1.OutputPlan(parentLayerPlan, $step, OUTPUT_PLAN_TYPE_ARRAY, locationDetails);
+            const $list = (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(parentLayerPlan, polymorphicPaths, connection_js_1.itemsOrStep, null, $step);
+            if ($list !== $step) {
+                $list._stepOptions.stream = $step._stepOptions.stream;
+            }
+            $list._stepOptions.walkIterable = true;
+            const listOutputPlan = new OutputPlan_js_1.OutputPlan(parentLayerPlan, $list, OUTPUT_PLAN_TYPE_ARRAY, locationDetails);
             parentOutputPlan.addChild(parentObjectType, responseKey, {
                 type: "outputPlan",
                 outputPlan: listOutputPlan,
                 isNonNull,
                 locationDetails,
             });
-            const $__item = this.itemStepForListStep(parentLayerPlan, $step, listDepth);
-            const $item = (0, step_js_1.isListCapableStep)($step)
-                ? (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)($__item.layerPlan, polymorphicPaths, $step.listItem, $step, $__item)
-                : $__item;
-            this.planIntoOutputPlan(listOutputPlan, $item.layerPlan, path, polymorphicPath, polymorphicPaths, selections, null, null, nullableFieldType.ofType, $item, locationDetails, listDepth + 1);
+            const stream = streamDetails
+                ? {
+                    // These are already marked as internal dependencies
+                    initialCountStepId: streamDetails.initialCount.id,
+                    ifStepId: streamDetails.if.id,
+                    labelStepId: streamDetails.label.id,
+                }
+                : undefined;
+            let $__item = this.itemStepForListStep(parentLayerPlan, $list, listDepth, stream);
+            const $sideEffect = $__item.layerPlan.latestSideEffectStep;
+            try {
+                let $item;
+                if ((0, step_js_1.isListCapableStep)($list)) {
+                    $item = (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)($__item.layerPlan, $__item.polymorphicPaths, $list.listItem, $list, $__item);
+                    this.deduplicateSteps();
+                    // Refetch steps following deduplicate
+                    $__item = this.stepTracker.getStepById($__item.id);
+                    $item = this.stepTracker.getStepById($item.id);
+                }
+                else {
+                    $item = $__item;
+                }
+                this.planIntoOutputPlan(listOutputPlan, $item.layerPlan, path, polymorphicPath, polymorphicPaths, selections, null, null, nullableFieldType.ofType, $item, locationDetails, resolverEmulation, listDepth + 1, null);
+            }
+            finally {
+                $__item.layerPlan.latestSideEffectStep = $sideEffect;
+            }
         }
         else if (isScalarType(nullableFieldType)) {
             const scalarPlanResolver = nullableFieldType.extensions?.grafast?.plan;
-            if (scalarPlanResolver?.constructor?.name === "AsyncFunction") {
-                throw new Error(`Plans must be synchronous, but this schema has an async function at '${nullableFieldType.name}.plan': ${scalarPlanResolver.toString()}`);
+            const fnDescription = `${nullableFieldType.name}.plan`;
+            (0, utils_js_1.assertNotAsync)(scalarPlanResolver, fnDescription);
+            const $sideEffect = parentLayerPlan.latestSideEffectStep;
+            try {
+                const $leaf = typeof scalarPlanResolver === "function"
+                    ? (0, utils_js_1.assertNotPromise)((0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(parentLayerPlan, polymorphicPaths, scalarPlanResolver, null, $step, this.scalarPlanInfo), scalarPlanResolver, fnDescription)
+                    : $step;
+                parentOutputPlan.addChild(parentObjectType, responseKey, {
+                    type: "outputPlan",
+                    isNonNull,
+                    outputPlan: new OutputPlan_js_1.OutputPlan(parentLayerPlan, $leaf, {
+                        mode: "leaf",
+                        // stepId: $leaf.id,
+                        graphqlType: nullableFieldType,
+                    }, locationDetails),
+                    locationDetails,
+                });
+            }
+            finally {
+                parentLayerPlan.latestSideEffectStep = $sideEffect;
             }
-            const $leaf = typeof scalarPlanResolver === "function"
-                ? (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(parentLayerPlan, polymorphicPaths, scalarPlanResolver, null, $step, this.scalarPlanInfo)
-                : $step;
-            parentOutputPlan.addChild(parentObjectType, responseKey, {
-                type: "outputPlan",
-                isNonNull,
-                outputPlan: new OutputPlan_js_1.OutputPlan(parentLayerPlan, $leaf, {
-                    mode: "leaf",
-                    // stepId: $leaf.id,
-                    graphqlType: nullableFieldType,
-                }, locationDetails),
-                locationDetails,
-            });
         }
         else if (isEnumType(nullableFieldType)) {
-            parentOutputPlan.addChild(parentObjectType, responseKey, {
-                type: "outputPlan",
-                isNonNull,
-                outputPlan: new OutputPlan_js_1.OutputPlan(parentLayerPlan, $step, {
-                    mode: "leaf",
-                    graphqlType: nullableFieldType,
-                }, locationDetails),
-                locationDetails,
-            });
+            const $sideEffect = parentLayerPlan.latestSideEffectStep;
+            try {
+                parentOutputPlan.addChild(parentObjectType, responseKey, {
+                    type: "outputPlan",
+                    isNonNull,
+                    outputPlan: new OutputPlan_js_1.OutputPlan(parentLayerPlan, $step, {
+                        mode: "leaf",
+                        graphqlType: nullableFieldType,
+                    }, locationDetails),
+                    locationDetails,
+                });
+            }
+            finally {
+                parentLayerPlan.latestSideEffectStep = $sideEffect;
+            }
         }
         else if (isObjectType(nullableFieldType)) {
-            if (isDev) {
+            if (index_js_1.isDev) {
                 // Check that the plan we're dealing with is the one the user declared
                 /** Either an assertion function or a step class */
                 const stepAssertion = nullableFieldType.extensions?.grafast?.assertStep;
                 if (stepAssertion != null) {
                     try {
-                        if (stepAssertion === index_js_1.ExecutableStep ||
-                            stepAssertion.prototype instanceof index_js_1.ExecutableStep) {
+                        if (stepAssertion === index_js_1.Step ||
+                            stepAssertion.prototype instanceof index_js_1.Step) {
                             if (!($step instanceof stepAssertion)) {
                                 throw new Error(`Step mis-match: expected ${stepAssertion.name}, but instead found ${$step.constructor.name} (${$step})`);
                             }
@@ -866,7 +947,7 @@ class OperationPlan {
                         }
                     }
                     catch (e) {
-                        throw new Error(`The step returned by '${path.join(".")}' is not compatible with the GraphQL object type '${nullableFieldType.name}': ${e.message}`, { cause: e });
+                        throw new Error(`The step returned by '${path.join(".")}${"[]".repeat(listDepth)}' is not compatible with the GraphQL object type '${nullableFieldType.name}': ${e.message}`, { cause: e });
                     }
                 }
                 if (!selections) {
@@ -894,18 +975,24 @@ class OperationPlan {
                     objectLayerPlan.setRootStep($step);
                 }
             }
-            const objectOutputPlan = new OutputPlan_js_1.OutputPlan(objectLayerPlan, $step, {
-                mode: "object",
-                deferLabel: undefined,
-                typeName: nullableFieldType.name,
-            }, locationDetails);
-            parentOutputPlan.addChild(parentObjectType, responseKey, {
-                type: "outputPlan",
-                outputPlan: objectOutputPlan,
-                isNonNull,
-                locationDetails,
-            });
-            this.planSelectionSet(objectOutputPlan, path, polymorphicPath, polymorphicPaths, $step, nullableFieldType, selections);
+            const $sideEffect = objectLayerPlan.latestSideEffectStep;
+            try {
+                const objectOutputPlan = new OutputPlan_js_1.OutputPlan(objectLayerPlan, $step, {
+                    mode: "object",
+                    deferLabel: undefined,
+                    typeName: nullableFieldType.name,
+                }, locationDetails);
+                parentOutputPlan.addChild(parentObjectType, responseKey, {
+                    type: "outputPlan",
+                    outputPlan: objectOutputPlan,
+                    isNonNull,
+                    locationDetails,
+                });
+                this.planSelectionSet(objectOutputPlan, path, polymorphicPath, polymorphicPaths, $step, nullableFieldType, selections, resolverEmulation);
+            }
+            finally {
+                objectLayerPlan.latestSideEffectStep = $sideEffect;
+            }
         }
         else {
             // Polymorphic
@@ -971,48 +1058,54 @@ class OperationPlan {
                 const polyBase = polymorphicPath ?? "";
                 const $oldStep = $step;
                 for (const type of allPossibleObjectTypes) {
-                    /* TODO: this $oldStep / $step dance turned out to be necessary
-                     * because `$step` was being replaced in the following query against
-                     * the pggql_test `polymorpic` schema; but I'm not sure this is the
-                     * right behavior - shouldn't deduplication have been temporarily
-                     * disabled during this?
-                     *
-                     * ```graphql
-                     * {
-                     *   allSingleTableItems {
-                     *     nodes {
-                     *       id
-                     *       type
-                     *       singleTableItemsByParentIdList {
-                     *         id
-                     *         position
-                     *       }
-                     *     }
-                     *   }
-                     * }
-                     * ```
-                     */
-                    const $step = this.stepTracker.getStepById($oldStep.id);
-                    // Bit of a hack, but saves passing it around through all the arguments
-                    const newPolymorphicPath = `${polyBase}>${type.name}`;
-                    polymorphicLayerPlan.reason.polymorphicPaths.add(newPolymorphicPath);
-                    const newPolymorphicPaths = new Set();
-                    newPolymorphicPaths.add(newPolymorphicPath);
-                    const $root = (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(polymorphicLayerPlan, newPolymorphicPaths, $step.planForType, $step, type);
-                    const objectOutputPlan = new OutputPlan_js_1.OutputPlan(polymorphicLayerPlan, $root, {
-                        mode: "object",
-                        deferLabel: undefined,
-                        typeName: type.name,
-                    }, locationDetails);
-                    // find all selections compatible with `type`
-                    const fieldNodes = (0, graphqlMergeSelectionSets_js_1.fieldSelectionsForType)(this, type, selections);
-                    this.planSelectionSet(objectOutputPlan, path, newPolymorphicPath, newPolymorphicPaths, $root, type, fieldNodes, false);
-                    polymorphicOutputPlan.addChild(type, null, {
-                        type: "outputPlan",
-                        isNonNull,
-                        outputPlan: objectOutputPlan,
-                        locationDetails,
-                    });
+                    const $sideEffect = polymorphicLayerPlan.latestSideEffectStep;
+                    try {
+                        /* TODO: this $oldStep / $step dance turned out to be necessary
+                         * because `$step` was being replaced in the following query against
+                         * the graphilecrystaltest `polymorpic` schema; but I'm not sure this is the
+                         * right behavior - shouldn't deduplication have been temporarily
+                         * disabled during this?
+                         *
+                         * ```graphql
+                         * {
+                         *   allSingleTableItems {
+                         *     nodes {
+                         *       id
+                         *       type
+                         *       singleTableItemsByParentIdList {
+                         *         id
+                         *         position
+                         *       }
+                         *     }
+                         *   }
+                         * }
+                         * ```
+                         */
+                        const $step = this.stepTracker.getStepById($oldStep.id);
+                        // Bit of a hack, but saves passing it around through all the arguments
+                        const newPolymorphicPath = `${polyBase}>${type.name}`;
+                        polymorphicLayerPlan.reason.polymorphicPaths.add(newPolymorphicPath);
+                        const newPolymorphicPaths = new Set();
+                        newPolymorphicPaths.add(newPolymorphicPath);
+                        const $root = (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(polymorphicLayerPlan, newPolymorphicPaths, $step.planForType, $step, type);
+                        const objectOutputPlan = new OutputPlan_js_1.OutputPlan(polymorphicLayerPlan, $root, {
+                            mode: "object",
+                            deferLabel: undefined,
+                            typeName: type.name,
+                        }, locationDetails);
+                        // find all selections compatible with `type`
+                        const fieldNodes = (0, graphqlMergeSelectionSets_js_1.fieldSelectionsForType)(this, type, selections);
+                        this.planSelectionSet(objectOutputPlan, path, newPolymorphicPath, newPolymorphicPaths, $root, type, fieldNodes, false);
+                        polymorphicOutputPlan.addChild(type, null, {
+                            type: "outputPlan",
+                            isNonNull,
+                            outputPlan: objectOutputPlan,
+                            locationDetails,
+                        });
+                    }
+                    finally {
+                        polymorphicLayerPlan.latestSideEffectStep = $sideEffect;
+                    }
                 }
             }
         }
@@ -1061,15 +1154,23 @@ class OperationPlan {
             return layerPlan;
         }
     }
-    planField(layerPlan, path, polymorphicPaths, fieldNodes, planResolver, applyAfterMode, rawParentStep, field, trackedArguments, deduplicate = true) {
+    planField(typeName, fieldName, layerPlan, path, polymorphicPaths, planResolver, applyAfterMode, rawParentStep, field, trackedArguments, 
+    // If 'true' this is a subscription rather than a stream
+    // If 'false' this is a list but it will never stream
+    // If 'null' this is neither subscribe field nor list field
+    // Otherwise, it's a list field that has the `@stream` directive applied
+    streamDetails, deduplicate = true) {
+        const coordinate = `${typeName}.${fieldName}`;
         // The step may have been de-duped whilst sibling steps were planned
         // PERF: this should be handled in the parent?
         const parentStep = this.stepTracker.getStepById(rawParentStep.id);
         const previousStepCount = this.stepTracker.stepCount;
+        const previousSideEffectStep = layerPlan.latestSideEffectStep;
         if (this.loc !== null)
             this.loc.push(`planField(${path.join(".")})`);
         try {
-            let step = (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(layerPlan, polymorphicPaths, operationPlan_input_js_1.withFieldArgsForArguments, null, this, parentStep, trackedArguments, field, applyAfterMode, (fieldArgs) => planResolver(parentStep, fieldArgs, {
+            let step = (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(layerPlan, polymorphicPaths, operationPlan_input_js_1.withFieldArgsForArguments, null, this, trackedArguments, field, parentStep, applyAfterMode, coordinate, (fieldArgs) => planResolver(parentStep, fieldArgs, {
+                fieldName,
                 field,
                 schema: this.schema,
             }));
@@ -1083,31 +1184,22 @@ class OperationPlan {
                 haltTree = true;
             }
             (0, step_js_1.assertExecutableStep)(step);
-            // TODO: Check SameStreamDirective still exists in @stream spec at release.
-            /*
-             * `SameStreamDirective`
-             * (https://github.com/graphql/graphql-spec/blob/26fd78c4a89a79552dcc0c7e0140a975ce654400/spec/Section%205%20--%20Validation.md#L450-L458)
-             * ensures that every field that has `@stream` must have the same
-             * `@stream` arguments; so we can just check the first node in the
-             * merged set to see our stream options. NOTE: if this changes before
-             * release then we may need to find the stream with the largest
-             * `initialCount` to figure what to do; something like:
-             *
-             *      const streamDirective = firstField.directives?.filter(
-             *        (d) => d.name.value === "stream",
-             *      ).sort(
-             *        (a, z) => getArg(z, 'initialCount', 0) - getArg(a, 'initialCount', 0)
-             *      )[0]
-             */
-            const streamDirective = fieldNodes[0].directives?.find((d) => d.name.value === "stream");
-            const stepOptions = {
-                stream: !haltTree && streamDirective
-                    ? {
-                        initialCount: Number((0, graphqlCollectFields_js_1.evalDirectiveArg)(fieldNodes[0], "stream", "initialCount", this.trackedVariableValuesStep, null)) || 0,
-                    }
-                    : null,
-            };
-            step._stepOptions = stepOptions;
+            if (streamDetails === true) {
+                // subscription
+                step._stepOptions.stream = {};
+                step._stepOptions.walkIterable = true;
+            }
+            else if (streamDetails === false) {
+                step._stepOptions.walkIterable = true;
+            }
+            else if (streamDetails != null) {
+                step._stepOptions.stream = {
+                    initialCountStepId: streamDetails.initialCount.id,
+                    ifStepId: streamDetails.if.id,
+                    labelStepId: streamDetails.label.id,
+                };
+                step._stepOptions.walkIterable = true;
+            }
             if (deduplicate) {
                 // Now that the field has been planned (including arguments, but NOT
                 // including selection set) we can deduplicate it to see if any of its
@@ -1133,6 +1225,7 @@ class OperationPlan {
             }
             try {
                 this.stepTracker.purgeBackTo(previousStepCount);
+                layerPlan.latestSideEffectStep = previousSideEffectStep;
             }
             catch (e2) {
                 console.error(`Cleanup error occurred whilst trying to recover from field planning error: ${e2.stack}`);
@@ -1140,7 +1233,6 @@ class OperationPlan {
             }
             const step = (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(layerPlan, polymorphicPaths, index_js_1.error, null, e);
             const haltTree = true;
-            this.modifierSteps = [];
             // PERF: consider deleting all steps that were allocated during this. For
             // now we'll just rely on tree-shaking.
             return { step, haltTree };
@@ -1161,7 +1253,7 @@ class OperationPlan {
         const trackedArgumentValues = Object.create(null);
         for (const argumentDefinition of argumentDefinitions) {
             const argumentName = argumentDefinition.name;
-            if (isDev && trackedArgumentValues[argumentName]) {
+            if (index_js_1.isDev && trackedArgumentValues[argumentName]) {
                 throw new index_js_1.SafeError(`Argument name '${argumentName}' seen twice; aborting.`);
             }
             const argumentType = argumentDefinition.type;
@@ -1178,42 +1270,12 @@ class OperationPlan {
             },
         };
     }
-    withModifiers(cb) {
-        // Stash previous modifiers
-        const previousModifierDepthCount = this.modifierDepthCount++;
-        const previousCount = this.modifierStepCount;
-        const previousStack = this.modifierSteps.splice(0, this.modifierSteps.length);
-        this.modifierStepCount = 0;
-        let result;
-        let plansToApply;
-        try {
-            result = cb();
-        }
-        finally {
-            // Remove the modifier plans from operationPlan and sort them ready for application.
-            plansToApply = this.modifierSteps
-                .splice(0, this.modifierSteps.length)
-                .reverse();
-            // Restore previous modifiers
-            this.modifierStepCount = previousCount;
-            for (const mod of previousStack) {
-                this.modifierSteps.push(mod);
-            }
-            // Restore previous depth
-            this.modifierDepthCount = previousModifierDepthCount;
-        }
-        // Apply the plans.
-        for (let i = 0, l = plansToApply.length; i < l; i++) {
-            plansToApply[i].apply();
-        }
-        return result;
-    }
     /**
      * Sets up tracking for the given value (variableValues, context, rootValue).
      */
     track(value, constraints, variableDefinitions) {
-        const valueStep = (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(this.rootLayerPlan, exports.POLYMORPHIC_ROOT_PATHS, newValueStepCallback);
-        const trackedObjectStep = (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(this.rootLayerPlan, exports.POLYMORPHIC_ROOT_PATHS, () => new index_js_1.__TrackedValueStep(value, valueStep, constraints, [], variableDefinitions));
+        const valueStep = (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(this.rootLayerPlan, exports.POLYMORPHIC_ROOT_PATHS, newValueStepCallback, null, variableDefinitions != null);
+        const trackedObjectStep = (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(this.rootLayerPlan, exports.POLYMORPHIC_ROOT_PATHS, () => new index_js_1.__TrackedValueStep(value, valueStep, constraints, [], variableDefinitions != null, variableDefinitions));
         return [valueStep, trackedObjectStep];
     }
     /**
@@ -1227,7 +1289,8 @@ class OperationPlan {
                 continue;
             for (const key in step) {
                 const val = step[key];
-                if (val instanceof index_js_1.ExecutableStep) {
+                if (key !== "implicitSideEffectStep" &&
+                    val instanceof index_js_1.Step) {
                     errors.push(new Error(`ERROR: ExecutableStep ${step} has illegal reference via property '${key}' to step ${val}. You must not reference steps directly, instead add the step as a dependency (\`depId = this.addDependency($step)\`) and use \`this.getDep(depId)\` to look the step up (or, if the step is not a dependency, store the step ID and use \`this.getStep(stepId)\` each time you need to reference it). Failure to comply could result in subtle breakage during optimisation.`));
                 }
             }
@@ -1269,7 +1332,7 @@ class OperationPlan {
         }
         else {
             // used for: hoist
-            for (const $processFirst of step.dependencies) {
+            for (const $processFirst of (0, utils_js_1.sudo)(step).dependencies) {
                 if (!processed.has($processFirst)) {
                     this.processStep(actionDescription, order, isReadonly, callback, processed, $processFirst);
                 }
@@ -1311,6 +1374,8 @@ class OperationPlan {
      * @internal
      */
     processSteps(actionDescription, order, isReadonly, callback) {
+        if (index_js_1.isDev)
+            this.stepTracker.lockNewSteps();
         const previousStepCount = this.stepTracker.stepCount;
         const processed = new Set();
         for (let i = 0; i < this.stepTracker.stepCount; i++) {
@@ -1319,7 +1384,7 @@ class OperationPlan {
             if (!step || step.id !== i || processed.has(step))
                 continue;
             const resultStep = this.processStep(actionDescription, order, isReadonly, callback, processed, step);
-            if (isDev) {
+            if (index_js_1.isDev) {
                 const plansAdded = this.stepTracker.stepCount - previousStepCount;
                 // NOTE: whilst processing steps new steps may be added, thus we must loop
                 // ascending and we must re-evaluate this.stepTracker.stepCount on each loop
@@ -1328,8 +1393,13 @@ class OperationPlan {
                     throw new Error(`Whilst processing steps as part of ${actionDescription}Plans, ${plansAdded} new steps have been created... That seems like it's likely a bug in the relevant method of one of your steps. The last plan processed was ${resultStep}`);
                 }
             }
-            if (isReadonly && this.stepTracker.stepCount > previousStepCount) {
-                throwNoNewStepsError(this, actionDescription, step, previousStepCount, "Creating steps in isReadonly mode is forbidden");
+            if ((isReadonly || index_js_1.isDev) &&
+                this.stepTracker.stepCount > previousStepCount) {
+                if (isReadonly) {
+                    throwNoNewStepsError(this, actionDescription, step, previousStepCount, "Creating steps in isReadonly mode is forbidden");
+                }
+                if (index_js_1.isDev)
+                    this.stepTracker.lockNewSteps();
             }
         }
         if (!isReadonly &&
@@ -1348,17 +1418,48 @@ class OperationPlan {
      */
     getPeers(step) {
         if (step.hasSideEffects) {
+            // Plans with side effects have no peers.
+            return EMPTY_ARRAY;
+        }
+        if (step._stepOptions.stream) {
+            // Streams have no peers - we cannot reference the stream more
+            // than once (and we aim to not cache the stream because we want its
+            // entries to be garbage collected).
+            //
+            // HOWEVER! There may be lifecycle parts that need to be called... So
+            // call the function with an empty array; ignore the result.
             return EMPTY_ARRAY;
         }
-        const { dependencies: deps, layerPlan: layerPlan, constructor: stepConstructor, } = step;
+        // NOTE: Streams have no peers - we cannot reference the stream more than
+        // once (and we aim to not cache the stream because we want its entries to
+        // be garbage collected) - however if we're already fetching the list then
+        // we shouldn't fetch it again via stream... We should deduplicate a stream
+        // to return a non-stream.
+        if (step._stepOptions.stream != null) {
+            // TODO: remove this if block when we implement the new stream/defer -
+            // deduplicating a stream should be fine. (Not subscriptions though - may
+            // need a check for that!)
+            return EMPTY_ARRAY;
+        }
+        if (this.stepTracker.internalDependencies.has(step)) {
+            // PERF: we need to set up correct tracking, then internal deps can be deduped
+            return EMPTY_ARRAY;
+        }
+        const sstep = (0, utils_js_1.sudo)(step);
+        const { dependencies: deps, dependencyForbiddenFlags: flags, dependencyOnReject: onReject, layerPlan: layerPlan, constructor: stepConstructor, peerKey, } = sstep;
+        // const streamInitialCount = sstep._stepOptions.stream?.initialCount;
         const dependencyCount = deps.length;
         if (dependencyCount === 0) {
             let allPeers = null;
-            for (const possiblyPeer of this.stepTracker.stepsWithNoDependencies) {
+            const stepsWithNoDependencies = this.stepTracker.stepsWithNoDependenciesByConstructor.get(step.constructor) ?? new Set();
+            for (const possiblyPeer of stepsWithNoDependencies) {
                 if (possiblyPeer !== step &&
                     !possiblyPeer.hasSideEffects &&
                     possiblyPeer.layerPlan === layerPlan &&
-                    possiblyPeer.constructor === stepConstructor) {
+                    possiblyPeer._stepOptions.stream == null &&
+                    possiblyPeer.peerKey === peerKey
+                // && possiblyPeer._stepOptions.stream?.initialCount === streamInitialCount
+                ) {
                     if (allPeers === null) {
                         allPeers = [possiblyPeer];
                     }
@@ -1381,15 +1482,24 @@ class OperationPlan {
             }
             const minDepth = Math.max(deferBoundaryDepth, dep.layerPlan.depth);
             let allPeers = null;
-            for (const { dependencyIndex: peerDependencyIndex, step: possiblyPeer, } of dep.dependents) {
-                const { layerPlan: peerLayerPlan } = possiblyPeer;
-                if (possiblyPeer !== step &&
-                    peerDependencyIndex === 0 &&
-                    !possiblyPeer.hasSideEffects &&
-                    possiblyPeer.constructor === stepConstructor &&
-                    peerLayerPlan.depth >= minDepth &&
+            for (const { dependencyIndex: peerDependencyIndex, step: rawPossiblyPeer, } of dep.dependents) {
+                if (peerDependencyIndex !== 0 ||
+                    rawPossiblyPeer === step ||
+                    rawPossiblyPeer.hasSideEffects ||
+                    rawPossiblyPeer._stepOptions.stream != null ||
+                    rawPossiblyPeer.constructor !== stepConstructor ||
+                    rawPossiblyPeer.peerKey !== peerKey
+                // || rawPossiblyPeer._stepOptions.stream?.initialCount !== streamInitialCount
+                ) {
+                    continue;
+                }
+                const possiblyPeer = (0, utils_js_1.sudo)(rawPossiblyPeer);
+                const { layerPlan: peerLayerPlan, dependencyForbiddenFlags: peerFlags, dependencyOnReject: peerOnReject, } = possiblyPeer;
+                if (peerLayerPlan.depth >= minDepth &&
                     possiblyPeer.dependencies.length === dependencyCount &&
-                    peerLayerPlan === ancestry[peerLayerPlan.depth]) {
+                    peerLayerPlan === ancestry[peerLayerPlan.depth] &&
+                    peerFlags[0] === flags[0] &&
+                    peerOnReject[0] === onReject[0]) {
                     if (allPeers === null) {
                         allPeers = [possiblyPeer];
                     }
@@ -1413,7 +1523,8 @@ class OperationPlan {
              */
             let minDepth = deferBoundaryDepth;
             const possiblePeers = [];
-            for (let dependencyIndex = 0; dependencyIndex < dependencyCount; dependencyIndex++) {
+            // Loop backwards since last dependency is most likely to be most unique
+            for (let dependencyIndex = dependencyCount - 1; dependencyIndex >= 0; dependencyIndex--) {
                 const dep = deps[dependencyIndex];
                 const dl = dep.dependents.length;
                 if (dl === 1) {
@@ -1425,13 +1536,23 @@ class OperationPlan {
                     // Check the final dependency - this is likely to have the fewest
                     // dependents (since it was added last it's more likely to be
                     // unique).
-                    for (const { dependencyIndex: peerDependencyIndex, step: possiblyPeer, } of dep.dependents) {
-                        if (possiblyPeer !== step &&
-                            peerDependencyIndex === dependencyIndex &&
-                            !possiblyPeer.hasSideEffects &&
-                            possiblyPeer.constructor === stepConstructor &&
-                            possiblyPeer.dependencies.length === dependencyCount &&
-                            possiblyPeer.layerPlan === ancestry[possiblyPeer.layerPlan.depth]) {
+                    for (const { dependencyIndex: peerDependencyIndex, step: rawPossiblyPeer, } of dep.dependents) {
+                        if (peerDependencyIndex !== dependencyIndex ||
+                            rawPossiblyPeer === step ||
+                            rawPossiblyPeer.hasSideEffects ||
+                            rawPossiblyPeer._stepOptions.stream != null ||
+                            rawPossiblyPeer.constructor !== stepConstructor ||
+                            rawPossiblyPeer.peerKey !== peerKey
+                        // || rawPossiblyPeer._stepOptions.stream?.initialCount !== streamInitialCount
+                        ) {
+                            continue;
+                        }
+                        const possiblyPeer = (0, utils_js_1.sudo)(rawPossiblyPeer);
+                        const { layerPlan: peerLayerPlan, dependencyForbiddenFlags: peerFlags, dependencyOnReject: peerOnReject, dependencies: peerDependencies, } = possiblyPeer;
+                        if (peerDependencies.length === dependencyCount &&
+                            peerLayerPlan === ancestry[peerLayerPlan.depth] &&
+                            peerFlags[0] === flags[0] &&
+                            peerOnReject[0] === onReject[0]) {
                             possiblePeers.push(possiblyPeer);
                         }
                     }
@@ -1451,7 +1572,7 @@ class OperationPlan {
                 // We know the final dependency matches and the dependency count
                 // matches - check the other dependencies match.
                 for (let i = 0; i < dependencyCount - 1; i++) {
-                    if (deps[i] !== possiblyPeer.dependencies[i]) {
+                    if (deps[i] !== (0, utils_js_1.sudo)(possiblyPeer).dependencies[i]) {
                         continue outerloop;
                     }
                 }
@@ -1530,6 +1651,9 @@ class OperationPlan {
                     // unsafe. Should we do so, we should remove this.
                     break;
                 }
+                else if (step instanceof index_js_1.__FlagStep) {
+                    break;
+                }
                 else {
                     return;
                 }
@@ -1541,7 +1665,7 @@ class OperationPlan {
             case "nullableBoundary": {
                 // Safe to hoist _unless_ it depends on the root step of the nullableBoundary.
                 const $root = step.layerPlan.reason.parentStep;
-                if (step.dependencies.includes($root)) {
+                if ((0, utils_js_1.sudo)(step).dependencies.includes($root)) {
                     return;
                 }
                 else {
@@ -1567,6 +1691,9 @@ class OperationPlan {
                     // break;
                     return;
                 }
+                else if (step instanceof index_js_1.__FlagStep) {
+                    break;
+                }
                 else {
                     // Plans that rely on external state shouldn't be hoisted because
                     // their results may change after a mutation, so the mutation should
@@ -1580,7 +1707,7 @@ class OperationPlan {
             }
         }
         // Finally, check that none of its dependencies are in the same bucket.
-        const deps = step.dependencies;
+        const deps = (0, utils_js_1.sudo)(step).dependencies;
         if (deps.some((dep) => dep.layerPlan === step.layerPlan)) {
             return;
         }
@@ -1646,6 +1773,11 @@ class OperationPlan {
         if (this.isImmoveable(step)) {
             return step;
         }
+        if (step._isUnary) {
+            step._isUnaryLocked = true;
+            // Don't push unary steps down
+            return step;
+        }
         switch (step.layerPlan.reason.type) {
             case "root":
             case "subscription":
@@ -1783,34 +1915,25 @@ class OperationPlan {
         return step;
     }
     _deduplicateInnerLogic(step) {
-        if (step.hasSideEffects) {
-            // Never deduplicate plans with side effects.
-            return null;
-        }
         if (step instanceof index_js_1.__ItemStep) {
             // __ItemStep cannot be deduplicated
             return null;
         }
-        // OPTIMIZE: Past Benjie thought we might want to revisit this under the
-        // new Grafast system. No idea what he had in mind there though...
-        if (step._stepOptions.stream) {
-            // Never deduplicate streaming plans, we cannot reference the stream more
-            // than once (and we aim to not cache the stream because we want its
-            // entries to be garbage collected).
-            return null;
-        }
         const peers = this.getPeers(step);
-        // Even if there is just one peer, we must still deduplicate because
+        // Even if there are no peers, we must still deduplicate because
         // `deduplicate` is called to indicate that the field is done being
         // planned, which the step class may want to acknowledge by locking certain
         // facets of its functionality (such as adding filters). We'll simplify its
         // work though by giving it an empty array to filter.
+        const wasLocked = index_js_1.isDev && (0, lock_js_1.unlock)(step);
         const equivalentSteps = step.deduplicate(peers);
+        if (wasLocked)
+            (0, lock_js_1.lock)(step);
         if (equivalentSteps.length === 0) {
             // No other equivalents
             return null;
         }
-        if (isDev) {
+        if (index_js_1.isDev) {
             if (!equivalentSteps.every((replacementStep) => peers.includes(replacementStep))) {
                 throw new Error(`deduplicatePlan error: '${step}.deduplicate' may only return steps from its peers peers (peers = ${peers}), but it returned ${equivalentSteps}. This is currently forbidden because it could cause confusion during the optimization process, instead apply this change in 'optimize', or make sure that any child selections aren't applied until the optimize/finalize phase so that no mapping is required during deduplicate.`);
             }
@@ -1832,7 +1955,14 @@ class OperationPlan {
         return { stepsAtMinDepth, equivalentSteps };
     }
     deduplicateStep(step) {
+        // Conditions applied to this step are now finalized, though we may still
+        // tell the step to do more stuff (like fetch extra data), it can no longer
+        // change its order, conditions, etc.
         step.isArgumentsFinalized = true;
+        // If a step is unary at this point, it must always remain unary.
+        if (step._isUnary) {
+            step._isUnaryLocked = true;
+        }
         if (step.deduplicate == null)
             return step;
         const result = this._deduplicateInnerLogic(step);
@@ -1851,14 +1981,24 @@ class OperationPlan {
             }
             winner.polymorphicPaths = polymorphicPaths;
         }
+        // Equivalent steps cannot be streaming; so we can no longer stream either.
+        if (equivalentSteps.length > 0) {
+            winner._stepOptions.stream = null;
+        }
         // Give the steps a chance to pass their responsibilities to the winner.
         if (winner !== step) {
+            const wasLocked = index_js_1.isDev && (0, lock_js_1.unlock)(step);
             step.deduplicatedWith?.(winner);
+            if (wasLocked)
+                (0, lock_js_1.lock)(step);
             this.stepTracker.replaceStep(step, winner);
         }
         for (const target of equivalentSteps) {
             if (winner !== target) {
+                const wasLocked = index_js_1.isDev && (0, lock_js_1.unlock)(target);
                 target.deduplicatedWith?.(winner);
+                if (wasLocked)
+                    (0, lock_js_1.lock)(target);
                 this.stepTracker.replaceStep(target, winner);
             }
         }
@@ -1896,12 +2036,12 @@ class OperationPlan {
      */
     deduplicateStepsProcess(processed, start, step) {
         processed.add(step);
-        for (const dep of step.dependencies) {
+        for (const dep of (0, utils_js_1.sudo)(step).dependencies) {
             if (dep.id >= start && !processed.has(dep)) {
                 this.deduplicateStepsProcess(processed, start, dep);
             }
         }
-        (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(step.layerPlan, step.polymorphicPaths, this.deduplicateStep, this, step);
+        (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(step.layerPlan, step.polymorphicPaths, this.phase === "plan" ? this.deduplicateStep : this.hoistAndDeduplicate, this, step);
     }
     /**
      * Gives us a chance to replace nearly-duplicate plans with other existing
@@ -1955,27 +2095,6 @@ class OperationPlan {
     pushDownSteps() {
         this.processSteps("pushDown", "dependents-first", false, this.pushDown);
     }
-    getStepOptionsForStep(step) {
-        return step._stepOptions;
-        /*
-        // NOTE: streams can only be merged if their parameters are compatible
-        // (namely they need to have equivalent `initialCount`)
-        const streamLayerPlan = step.childLayerPlans.find(
-          (lp) => lp.reason.type === "stream",
-        );
-    
-        // PERF: if step isn't streamable, don't create a streamLayerPlan because
-        // there's no point (and then we can leverage better optimisations).
-    
-        return {
-          stream:
-            streamLayerPlan && isStreamableStep(step)
-              ? // && streamLayerPlan.parentStep === step
-                { initialCount: streamLayerPlan.reason.initialCount }
-              : null,
-        };
-        */
-    }
     /**
      * Calls the 'optimize' method on a plan, which may cause the plan to
      * communicate with its (deep) dependencies, and even to replace itself with
@@ -1993,7 +2112,7 @@ class OperationPlan {
             return step;
         }
         // We know if it's streaming or not based on the LayerPlan it's contained within.
-        const stepOptions = this.getStepOptionsForStep(step);
+        // const stepOptions = step._stepOptions;
         let meta;
         if (step.optimizeMetaKey !== undefined) {
             meta = this.optimizeMeta.get(step.optimizeMetaKey);
@@ -2002,10 +2121,17 @@ class OperationPlan {
                 this.optimizeMeta.set(step.optimizeMetaKey, meta);
             }
         }
+        const wasLocked = index_js_1.isDev && (0, lock_js_1.unlock)(step);
         const replacementStep = step.optimize({
-            ...stepOptions,
+            stream: step._stepOptions.stream
+                ? {
+                // We could add more details here, but for now we don't really need them?
+                }
+                : null,
             meta,
         });
+        if (wasLocked)
+            (0, lock_js_1.lock)(step);
         if (!replacementStep) {
             throw new Error(`Bug in ${step}'s class: the 'optimize' method must return a step. Hint: did you forget 'return this;'?`);
         }
@@ -2051,14 +2177,67 @@ class OperationPlan {
             .slice(0, 10)
             .join(", ")}`);
     }
+    inlineSteps() {
+        flagLoop: for (const $flag of this.stepTracker.activeSteps) {
+            if ($flag instanceof index_js_1.__FlagStep) {
+                // We can only inline it if it's not used by an output plan or layer plan
+                {
+                    const usages = this.stepTracker.outputPlansByRootStep.get($flag);
+                    if (usages?.size) {
+                        continue;
+                    }
+                }
+                {
+                    const usages = this.stepTracker.layerPlansByRootStep.get($flag);
+                    if (usages?.size) {
+                        continue;
+                    }
+                }
+                {
+                    const usages = this.stepTracker.layerPlansByParentStep.get($flag);
+                    if (usages?.size) {
+                        continue;
+                    }
+                }
+                // We're only going to inline one if we can inline all.
+                const toInline = [];
+                for (const dependent of $flag.dependents) {
+                    const { step, dependencyIndex } = dependent;
+                    const $dependent = (0, utils_js_1.sudo)(step);
+                    const inlineDetails = $flag.inline($dependent.getDepOptions(dependencyIndex));
+                    if (inlineDetails === null) {
+                        continue flagLoop;
+                    }
+                    toInline.push({
+                        $dependent,
+                        dependencyIndex,
+                        inlineDetails,
+                        dependent,
+                    });
+                }
+                // All of them pass the check, let's inline them
+                for (const todo of toInline) {
+                    const { $dependent, dependencyIndex, inlineDetails: { onReject, acceptFlags = interfaces_js_1.DEFAULT_ACCEPT_FLAGS }, } = todo;
+                    (0, utils_js_1.writeableArray)($dependent.dependencyOnReject)[dependencyIndex] =
+                        onReject;
+                    (0, utils_js_1.writeableArray)($dependent.dependencyForbiddenFlags)[dependencyIndex] =
+                        interfaces_js_1.ALL_FLAGS & ~acceptFlags;
+                }
+                const $flagDep = (0, utils_js_1.sudo)($flag).dependencies[0];
+                this.stepTracker.replaceStep($flag, $flagDep);
+            }
+        }
+    }
     /** Finalizes each step */
     finalizeSteps() {
         const initialStepCount = this.stepTracker.stepCount;
-        assert.strictEqual(this.modifierSteps.length, 0, "No modifier steps expected when performing finalizeSteps");
         for (const step of this.stepTracker.activeSteps) {
+            const wasLocked = index_js_1.isDev && (0, lock_js_1.unlock)(step);
             step.finalize();
+            if (wasLocked)
+                (0, lock_js_1.lock)(step);
             (0, step_js_1.assertFinalized)(step);
-            if (isDev && this.stepTracker.stepCount !== initialStepCount) {
+            if (index_js_1.isDev && this.stepTracker.stepCount !== initialStepCount) {
                 throw new Error(`When calling ${step}.finalize() a new plan was created; this is forbidden!`);
             }
         }
@@ -2074,9 +2253,13 @@ class OperationPlan {
                 if (currentLayerPlan.copyStepIds.includes(dep.id)) {
                     break;
                 }
-                if (isDev && this.stepTracker.getStepById(dep.id) !== dep) {
+                const targetStep = this.stepTracker.getStepById(dep.id);
+                if (index_js_1.isDev && targetStep !== dep) {
                     throw new Error(`GrafastInternalError<b291b110-396a-4c9c-814a-5466af3c50e8>: Plan mismatch; are we using a replaced step? Step ID: ${dep.id}; step: ${dep}; stepById: ${this.stepTracker.getStepById(dep.id)}`);
                 }
+                if (targetStep._isUnary) {
+                    targetStep._isUnaryLocked = true;
+                }
                 currentLayerPlan.copyStepIds.push(dep.id);
                 currentLayerPlan = currentLayerPlan.parentLayerPlan;
                 if (!currentLayerPlan) {
@@ -2101,15 +2284,17 @@ class OperationPlan {
             const sideEffectSteps = layerPlan.pendingSteps.filter((s) => s.hasSideEffects);
             const pending = new Set(layerPlan.pendingSteps);
             const processed = new Set();
+            let latestSideEffectStep = null;
             const processSideEffectPlan = (step) => {
                 if (processed.has(step) || isPrepopulatedStep(step)) {
                     return;
                 }
+                const sstep = (0, utils_js_1.sudo)(step);
                 processed.add(step);
                 pending.delete(step);
                 const sideEffectDeps = [];
                 const rest = [];
-                for (const dep of step.dependencies) {
+                for (const dep of sstep.dependencies) {
                     if (dep.layerPlan !== layerPlan) {
                         continue;
                     }
@@ -2132,6 +2317,13 @@ class OperationPlan {
                 for (const dep of rest) {
                     processSideEffectPlan(dep);
                 }
+                if (latestSideEffectStep !== null &&
+                    !(0, utils_js_1.stepADependsOnStepB)(sstep, latestSideEffectStep)) {
+                    sstep.implicitSideEffectStep = latestSideEffectStep;
+                }
+                if (step.hasSideEffects) {
+                    latestSideEffectStep = step;
+                }
                 const phase = /*#__INLINE__*/ newLayerPlanPhase();
                 phase.checkTimeout = true;
                 phase.normalSteps = [{ step }];
@@ -2142,7 +2334,7 @@ class OperationPlan {
                 processSideEffectPlan(sideEffectStep);
             }
             const readyToExecute = (step) => {
-                for (const dep of step.dependencies) {
+                for (const dep of (0, utils_js_1.sudo)(step).dependencies) {
                     if (dep.layerPlan === layerPlan && pending.has(dep)) {
                         return false;
                     }
@@ -2166,7 +2358,12 @@ class OperationPlan {
                 for (const step of nextSteps) {
                     processed.add(step);
                     pending.delete(step);
-                    if (step.isSyncAndSafe && (0, step_js_1.isUnbatchedExecutableStep)(step)) {
+                    const sstep = (0, utils_js_1.sudo)(step);
+                    if (latestSideEffectStep !== null &&
+                        !(0, utils_js_1.stepADependsOnStepB)(sstep, latestSideEffectStep)) {
+                        sstep.implicitSideEffectStep = latestSideEffectStep;
+                    }
+                    if (step.isSyncAndSafe && (0, step_js_1.isUnbatchedStep)(step)) {
                         if (phase.unbatchedSyncAndSafeSteps !== undefined) {
                             phase.unbatchedSyncAndSafeSteps.push({
                                 step,
@@ -2196,10 +2393,15 @@ class OperationPlan {
                 do {
                     foundOne = false;
                     for (const step of pending) {
-                        if (step.isSyncAndSafe && (0, step_js_1.isUnbatchedExecutableStep)(step)) {
+                        if (step.isSyncAndSafe && (0, step_js_1.isUnbatchedStep)(step)) {
                             if (readyToExecute(step)) {
                                 processed.add(step);
                                 pending.delete(step);
+                                const sstep = (0, utils_js_1.sudo)(step);
+                                if (latestSideEffectStep !== null &&
+                                    !(0, utils_js_1.stepADependsOnStepB)(sstep, latestSideEffectStep)) {
+                                    sstep.implicitSideEffectStep = latestSideEffectStep;
+                                }
                                 foundOne = true;
                                 if (phase.unbatchedSyncAndSafeSteps !== undefined) {
                                     phase.unbatchedSyncAndSafeSteps.push({
@@ -2235,13 +2437,34 @@ class OperationPlan {
                 if (step_js_1.$$noExec in step) {
                     continue;
                 }
-                for (const dep of step.dependencies) {
+                for (const dep of (0, utils_js_1.sudo)(step).dependencies) {
                     ensurePlanAvailableInLayer(dep, layerPlan);
                 }
+                if (step.implicitSideEffectStep) {
+                    ensurePlanAvailableInLayer(step.implicitSideEffectStep, layerPlan);
+                }
             }
             const $root = layerPlan.rootStep;
             if ($root) {
                 ensurePlanAvailableInLayer($root, layerPlan);
+                // If $root explicitly dependends on `layerPlan.parentSideEffectStep`
+                // then we should remove the implicit layerPlan dependency (e.g. so
+                // that if you `trap()` the error it does not interfere).
+                if (layerPlan.parentSideEffectStep) {
+                    if (layerPlan.parentSideEffectStep === $root ||
+                        layerPlan.parentSideEffectStep === $root.implicitSideEffectStep ||
+                        (0, utils_js_1.stepADependsOnStepB)($root, layerPlan.parentSideEffectStep)) {
+                        layerPlan.parentSideEffectStep = null;
+                    }
+                }
+            }
+            const $sideEffect = layerPlan.parentSideEffectStep;
+            if ($sideEffect) {
+                // We read it from the parent layer plan at newBucket time, but we
+                // don't need to actually scale it up/down.
+                //
+                // If parentSideEffectStep exists then parentLayerPlan must exist.
+                ensurePlanAvailableInLayer($sideEffect, layerPlan.parentLayerPlan);
             }
             // Copy polymorphic parentStepId
             if (layerPlan.reason.type === "polymorphic") {
@@ -2252,6 +2475,18 @@ class OperationPlan {
             if (layerPlan.reason.type === "listItem") {
                 const parentStep = layerPlan.reason.parentStep;
                 ensurePlanAvailableInLayer(parentStep, layerPlan.parentLayerPlan);
+                const stream = layerPlan.reason.stream;
+                if (stream != null) {
+                    if (stream.initialCountStepId) {
+                        ensurePlanAvailableInLayer(this.stepTracker.getStepById(stream.initialCountStepId), layerPlan.parentLayerPlan);
+                    }
+                    if (stream.ifStepId) {
+                        ensurePlanAvailableInLayer(this.stepTracker.getStepById(stream.ifStepId), layerPlan.parentLayerPlan);
+                    }
+                    if (stream.labelStepId) {
+                        ensurePlanAvailableInLayer(this.stepTracker.getStepById(stream.labelStepId), layerPlan.parentLayerPlan);
+                    }
+                }
             }
         }
         // Populate copyPlanIds for output plans' rootStepId
@@ -2294,18 +2529,26 @@ class OperationPlan {
     generatePlanJSON() {
         function printStep(step) {
             const metaString = step.toStringMeta();
+            const sstep = (0, utils_js_1.sudo)(step);
             return {
                 id: step.id,
                 stepClass: step.constructor.name,
                 metaString: metaString ? (0, index_js_1.stripAnsi)(metaString) : metaString,
+                isUnary: step._isUnary,
                 bucketId: step.layerPlan.id,
-                dependencyIds: step.dependencies.map((d) => d.id),
+                implicitSideEffectStepId: step.implicitSideEffectStep?.id ?? null,
+                dependencyIds: sstep.dependencies.map((d) => d.id),
+                dependencyForbiddenFlags: sstep.dependencyForbiddenFlags.slice(),
+                dependencyOnReject: sstep.dependencyOnReject.map((or) => or ? String(or) : or),
                 polymorphicPaths: step.polymorphicPaths
                     ? [...step.polymorphicPaths]
                     : undefined,
                 isSyncAndSafe: step.isSyncAndSafe || undefined,
                 supportsUnbatched: typeof step.unbatchedExecute === "function" || undefined,
                 hasSideEffects: step.hasSideEffects || undefined,
+                stream: step._stepOptions.stream
+                    ? { initialCountStepId: step._stepOptions.stream.initialCountStepId }
+                    : undefined,
                 extra: step.planJSONExtra(),
             };
         }
@@ -2365,6 +2608,7 @@ class OperationPlan {
             return {
                 id: lp.id,
                 reason: printBucketReason(lp.reason),
+                parentSideEffectStepId: lp.parentSideEffectStep?.id ?? null,
                 copyStepIds: lp.copyStepIds,
                 phases: lp.phases.map(printPhase),
                 steps: lp.steps.map(printStep),
@@ -2383,7 +2627,7 @@ class OperationPlan {
         const process = (lp, known) => {
             for (const step of this.stepTracker.activeSteps) {
                 if (step.layerPlan === lp) {
-                    for (const dep of step.dependencies) {
+                    for (const dep of (0, utils_js_1.sudo)(step).dependencies) {
                         if (!known.includes(dep.layerPlan)) {
                             // Naughty naughty
                             subroutineStep.addDependency(dep);
@@ -2423,13 +2667,61 @@ class OperationPlan {
         }
         return matches;
     }
+    /**
+     * Cache a generated step by a given identifier (cacheKey) such that we don't
+     * need to regenerate it on future calls, significantly reducing the load on
+     * deduplication later.
+     *
+     * Note: automatically extends the cached step into other (relevant)
+     * polymorphic paths; if this shouldn't be the case then don't use cacheStep
+     * and instead rely on deduplication as usual.
+     *
+     * @experimental
+     */
+    cacheStep(ownerStep, actionKey, cacheKey, cb) {
+        const layerPlan = (0, withGlobalLayerPlan_js_1.currentLayerPlan)();
+        const paths = (0, withGlobalLayerPlan_js_1.currentPolymorphicPaths)();
+        const cache = (this._cacheStepStoreByLayerPlanAndActionKey[`${actionKey}|${layerPlan.id}|${ownerStep.id}`] ??= new Map());
+        const cacheIt = () => {
+            const stepToCache = cb();
+            if (!(stepToCache instanceof index_js_1.Step)) {
+                throw new Error(`The callback passed to cacheStep must always return an ExecutableStep; but this call from ${ownerStep} returned instead ${(0, inspect_js_1.inspect)(stepToCache)}`);
+            }
+            cache.set(cacheKey, stepToCache.id);
+            return stepToCache;
+        };
+        if (!cache.has(cacheKey)) {
+            return cacheIt();
+        }
+        const cachedStepId = cache.get(cacheKey);
+        const cachedStep = this.stepTracker.stepById[cachedStepId];
+        if (cachedStep) {
+            // Fix poly paths
+            if (paths && cachedStep.polymorphicPaths) {
+                const polymorphicPaths = new Set([
+                    ...cachedStep.polymorphicPaths,
+                    ...paths,
+                ]);
+                cachedStep.polymorphicPaths = polymorphicPaths;
+            }
+            return cachedStep;
+        }
+        else {
+            return cacheIt();
+        }
+    }
+    /**
+     * Clears the cache, typically due to side effects having taken place. Called
+     * from setting hasSideEffects on an ExecutableStep, among other places.
+     */
+    resetCache() {
+        this._cacheStepStoreByLayerPlanAndActionKey = Object.create(null);
+    }
+    withRootLayerPlan(cb) {
+        return (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(this.rootLayerPlan, exports.POLYMORPHIC_ROOT_PATHS, cb);
+    }
 }
 exports.OperationPlan = OperationPlan;
-function makeDefaultPlan(fieldName) {
-    return ($step) => typeof $step.get === "function"
-        ? $step.get(fieldName)
-        : (0, access_js_1.access)($step, [fieldName]);
-}
 function makeMetaByMetaKeysFactory(allMetaKeysList) {
     const l = allMetaKeysList.length;
     // Optimize the common cases