grafast 0.1.1-beta.21 → 0.1.1-beta.23

package/dist/engine/OperationPlan.js

@@ -6,12 +6,12 @@ const lru_1 = tslib_1.__importDefault(require("@graphile/lru"));
 const graphql = tslib_1.__importStar(require("graphql"));
 const tamedevil_1 = tslib_1.__importDefault(require("tamedevil"));
 const assert = tslib_1.__importStar(require("../assert.js"));
+const constants_js_1 = require("../constants.js");
 const graphqlCollectFields_js_1 = require("../graphqlCollectFields.js");
 const graphqlMergeSelectionSets_js_1 = require("../graphqlMergeSelectionSets.js");
 const index_js_1 = require("../index.js");
 const input_js_1 = require("../input.js");
 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 connection_js_1 = require("../steps/connection.js");
@@ -28,6 +28,7 @@ const StepTracker_js_1 = require("./StepTracker.js");
 const atpe = typeof process !== "undefined" && process.env.ALWAYS_THROW_PLANNING_ERRORS;
 const ALWAYS_THROW_PLANNING_ERRORS = atpe === "1";
 const THROW_PLANNING_ERRORS_ON_SIDE_EFFECTS = atpe === "2";
+const DEFAULT_MAX_DEPTH = 100;
 /**
  * Returns true for steps that the system populates automatically without executing.
  */
@@ -48,6 +49,7 @@ const { assertObjectType, defaultFieldResolver, getNamedType, getNullableType, i
  */
 let planningTimeoutWarmupMultiplier = 5;
 const EMPTY_ARRAY = Object.freeze([]);
+const EMPTY_SET = new Set();
 exports.POLYMORPHIC_ROOT_PATH = null;
 exports.POLYMORPHIC_ROOT_PATHS = null;
 Object.freeze(exports.POLYMORPHIC_ROOT_PATHS);
@@ -57,20 +59,20 @@ 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 = (isImmutable) => new index_js_1.__ValueStep(isImmutable);
-const NO_ARGS = {
-    get() {
-        throw new Error(`This field doesn't have any arguments`);
-    },
-};
+const NO_ARGS = Object.create(null);
 class OperationPlan {
-    constructor(schema, operation, fragments, variableValuesConstraints, variableValues, contextConstraints, context, rootValueConstraints, rootValue, planningTimeout) {
+    constructor(schema, operation, fragments, variableValuesConstraints, variableValues, contextConstraints, context, rootValueConstraints, rootValue, options) {
         this.schema = schema;
         this.operation = operation;
         this.fragments = fragments;
         this.variableValues = variableValues;
         this.context = context;
         this.rootValue = rootValue;
-        this.planningTimeout = planningTimeout;
+        /**
+         * For use by `inputStep()` only.
+         * @internal
+         */
+        this._inputStepCache = new Map();
         /**
          * What state is the OpPlan in?
          *
@@ -95,7 +97,7 @@ class OperationPlan {
         /**
          * @internal
          */
-        this.itemStepIdByListStepId = Object.create(null);
+        this.itemStepIdByListStepIdByParentLayerPlanId = Object.create(null);
         /**
          * If true, then this operation doesn't use (custom) resolvers.
          */
@@ -106,6 +108,7 @@ class OperationPlan {
         this.optimizeMeta = new Map();
         /** @internal */
         this.valueNodeToStaticValueCache = new Map();
+        this.frozenPlanningPaths = index_js_1.isDev ? null : new Set();
         /** @internal Use plan.getStep(id) instead. */
         this.getStep = index_js_1.isDev
             ? (id, requestingStep) => {
@@ -122,14 +125,28 @@ class OperationPlan {
                 if (step == null) {
                     throw new Error(`Programming error: step with id '${id}' no longer exists (attempted access from ${requestingStep}). Most likely this means that ${requestingStep} has an illegal reference to this step, you should only maintain references to steps via dependencies.`);
                 }
-                return step[interfaces_js_1.$$proxy] ?? step;
+                return step[constants_js_1.$$proxy] ?? step;
             }
             : (id, _requestingStep) => {
                 const step = this.stepTracker.getStepById(id);
-                return step[interfaces_js_1.$$proxy] ?? step;
+                return step[constants_js_1.$$proxy] ?? step;
             };
-        this.polymorphicLayerPlanByPathByLayerPlan = new Map();
-        this._cacheStepStoreByLayerPlanAndActionKey = Object.create(null);
+        // This is the queue of things to be done _IN ORDER_
+        this.planningQueue = [];
+        // This is the queue of things to be done grouped by their planning path.
+        // The result of this is not necessarily in order, but it does save us
+        // time and effort in `planPending()`
+        this.planningQueueByPlanningPath = new Map();
+        this.planFieldBatch = null;
+        this._cacheStepStoreByActionKeyByLayerPlan = new Map();
+        this._immutableCacheStepStoreAndActionKey = Object.create(null);
+        this.planningTimeout = options?.timeouts?.planning ?? null;
+        this.maxPlanningDepth = options?.maxPlanningDepth ?? DEFAULT_MAX_DEPTH;
+        this.resolveInfoOperationBase = {
+            schema,
+            operation,
+            fragments,
+        };
         this.variableValuesConstraints = variableValuesConstraints;
         this.contextConstraints = contextConstraints;
         this.rootValueConstraints = rootValueConstraints;
@@ -165,7 +182,7 @@ class OperationPlan {
         }
         this.operationType = operation.operation;
         this.phase = "plan";
-        this.rootLayerPlan = new LayerPlan_js_1.LayerPlan(this, null, REASON_ROOT);
+        this.rootLayerPlan = new LayerPlan_js_1.LayerPlan(this, REASON_ROOT);
         // 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);
@@ -293,8 +310,8 @@ class OperationPlan {
         const elapsed = now - this.startTime;
         if (elapsed > this.planningTimeout * planningTimeoutWarmupMultiplier) {
             throw new index_js_1.SafeError("Operation took too long to plan and was aborted. Please simplify the request and try again.", {
-                [interfaces_js_1.$$timeout]: this.planningTimeout,
-                [interfaces_js_1.$$ts]: now,
+                [constants_js_1.$$timeout]: this.planningTimeout,
+                [constants_js_1.$$ts]: now,
             });
         }
     }
@@ -380,7 +397,18 @@ 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, true);
+        this.queueNextLayer(this.planSelectionSet, {
+            outputPlan,
+            path: [],
+            planningPath: rootType.name + ".",
+            polymorphicPaths: exports.POLYMORPHIC_ROOT_PATHS,
+            parentStep: this.trackedRootValueStep,
+            positionType: rootType,
+            layerPlan: this.rootLayerPlan,
+            selections: this.operation.selectionSet.selections,
+            resolverEmulation: true,
+        });
+        this.planPending();
         if (this.loc !== null)
             this.loc.pop();
     }
@@ -394,7 +422,6 @@ class OperationPlan {
         if (!rootType) {
             throw new index_js_1.SafeError("No mutation type found in schema");
         }
-        this.deduplicateSteps();
         const locationDetails = {
             node: this.operation.selectionSet.selections,
             parentTypeName: null,
@@ -406,7 +433,19 @@ 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, true);
+        this.queueNextLayer(this.planSelectionSet, {
+            outputPlan,
+            path: [],
+            planningPath: rootType.name + ".",
+            polymorphicPaths: exports.POLYMORPHIC_ROOT_PATHS,
+            parentStep: this.trackedRootValueStep,
+            positionType: rootType,
+            layerPlan: this.rootLayerPlan,
+            selections: this.operation.selectionSet.selections,
+            resolverEmulation: true,
+            isMutation: true,
+        });
+        this.planPending();
         if (this.loc !== null)
             this.loc.pop();
     }
@@ -420,8 +459,9 @@ class OperationPlan {
         if (!rootType) {
             throw new index_js_1.SafeError("No subscription type found in schema");
         }
+        const planningPath = rootType.name + ".";
         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, (0, graphqlCollectFields_js_1.newSelectionSetDigest)(false));
+        const groupedFieldSet = (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(this.rootLayerPlan, exports.POLYMORPHIC_ROOT_PATHS, planningPath, 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");
         }
@@ -452,46 +492,63 @@ class OperationPlan {
         const subscriptionPlanResolver = rawSubscriptionPlanResolver;
         const fieldArgsSpec = fieldSpec.args;
         const trackedArguments = fieldArgsSpec.length > 0
-            ? (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(this.rootLayerPlan, exports.POLYMORPHIC_ROOT_PATHS, this.getTrackedArguments, this, fieldArgsSpec, field)
+            ? (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(this.rootLayerPlan, exports.POLYMORPHIC_ROOT_PATHS, planningPath, this.getTrackedArguments, this, fieldArgsSpec, field)
             : NO_ARGS;
         if (subscriptionPlanResolver !== undefined) {
             // PERF: optimize this
-            const { haltTree, step: subscribeStep } = this.planField(rootType.name, fieldName, this.rootLayerPlan, path, exports.POLYMORPHIC_ROOT_PATHS, subscriptionPlanResolver, "subscribePlan", this.trackedRootValueStep, fieldSpec, trackedArguments, true);
+            const { haltTree, step: subscribeStep } = this.batchPlanField({
+                typeName: rootType.name,
+                fieldName,
+                layerPlan: this.rootLayerPlan,
+                path,
+                polymorphicPaths: exports.POLYMORPHIC_ROOT_PATHS,
+                planningPath,
+                planResolver: subscriptionPlanResolver,
+                applyAfterMode: "subscribePlan",
+                rawParentStep: this.trackedRootValueStep,
+                field: fieldSpec,
+                trackedArguments,
+                streamDetails: true,
+            })();
             if (haltTree) {
                 throw new index_js_1.SafeError("Failed to setup subscription");
             }
             this.rootLayerPlan.setRootStep(subscribeStep);
-            const subscriptionEventLayerPlan = new LayerPlan_js_1.LayerPlan(this, this.rootLayerPlan, {
+            const subscriptionEventLayerPlan = new LayerPlan_js_1.LayerPlan(this, {
                 type: "subscription",
+                parentLayerPlan: this.rootLayerPlan,
             });
-            const $__item = (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(subscriptionEventLayerPlan, exports.POLYMORPHIC_ROOT_PATHS, () => new index_js_1.__ItemStep(subscribeStep));
+            const $__item = (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(subscriptionEventLayerPlan, exports.POLYMORPHIC_ROOT_PATHS, planningPath, () => new index_js_1.__ItemStep(subscribeStep));
             subscriptionEventLayerPlan.setRootStep($__item);
-            let streamItemPlan = (0, utils_js_1.hasItemPlan)(subscribeStep)
-                ? (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(subscriptionEventLayerPlan, exports.POLYMORPHIC_ROOT_PATHS, subscribeStep.itemPlan, subscribeStep, $__item)
+            const streamItemPlan = (0, utils_js_1.hasItemPlan)(subscribeStep)
+                ? (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(subscriptionEventLayerPlan, exports.POLYMORPHIC_ROOT_PATHS, planningPath, subscribeStep.itemPlan, subscribeStep, $__item)
                 : $__item;
-            // WE MUST RE-FETCH STEPS AFTER DEDUPLICATION!
-            this.deduplicateSteps();
-            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, false);
+            this.queueNextLayer(this.planSelectionSet, {
+                outputPlan,
+                path: [],
+                planningPath,
+                polymorphicPaths: exports.POLYMORPHIC_ROOT_PATHS,
+                parentStep: streamItemPlan,
+                positionType: rootType,
+                layerPlan: subscriptionEventLayerPlan,
+                selections: selectionSet.selections,
+                resolverEmulation: false,
+            });
+            this.planPending();
         }
         else {
-            const subscribeStep = (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(this.rootLayerPlan, exports.POLYMORPHIC_ROOT_PATHS, () => {
-                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));
+            const subscribeStep = (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(this.rootLayerPlan, exports.POLYMORPHIC_ROOT_PATHS, planningPath, () => {
+                const $args = (0, index_js_1.object)(trackedArguments);
                 const rawResolver = fieldSpec.resolve;
                 const rawSubscriber = fieldSpec.subscribe;
                 return (0, graphqlResolver_js_1.graphqlResolver)(rawResolver, rawSubscriber, this.trackedRootValueStep, $args, {
+                    ...this.resolveInfoOperationBase,
                     fieldName,
                     fieldNodes: fields,
-                    fragments: this.fragments,
-                    operation: this.operation,
                     parentType: this.subscriptionType,
                     returnType: fieldSpec.type,
-                    schema: this.schema,
                     // @ts-ignore
                     path: {
                         typename: this.subscriptionType.name,
@@ -503,47 +560,81 @@ class OperationPlan {
             subscribeStep._stepOptions.stream = {};
             subscribeStep._stepOptions.walkIterable = true;
             this.rootLayerPlan.setRootStep(subscribeStep);
-            const subscriptionEventLayerPlan = new LayerPlan_js_1.LayerPlan(this, this.rootLayerPlan, {
+            const subscriptionEventLayerPlan = new LayerPlan_js_1.LayerPlan(this, {
                 type: "subscription",
+                parentLayerPlan: this.rootLayerPlan,
             });
-            const $__item = (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(subscriptionEventLayerPlan, exports.POLYMORPHIC_ROOT_PATHS, () => new index_js_1.__ItemStep(subscribeStep));
+            const $__item = (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(subscriptionEventLayerPlan, exports.POLYMORPHIC_ROOT_PATHS, planningPath, () => new index_js_1.__ItemStep(subscribeStep));
             subscriptionEventLayerPlan.setRootStep($__item);
-            let streamItemPlan = (0, utils_js_1.hasItemPlan)(subscribeStep)
-                ? (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(subscriptionEventLayerPlan, exports.POLYMORPHIC_ROOT_PATHS, subscribeStep.itemPlan, subscribeStep, $__item)
+            const streamItemPlan = (0, utils_js_1.hasItemPlan)(subscribeStep)
+                ? (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(subscriptionEventLayerPlan, exports.POLYMORPHIC_ROOT_PATHS, planningPath, subscribeStep.itemPlan, subscribeStep, $__item)
                 : $__item;
-            // WE MUST RE-FETCH STEPS AFTER DEDUPLICATION!
-            this.deduplicateSteps();
-            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, true);
+            this.queueNextLayer(this.planSelectionSet, {
+                outputPlan,
+                path: [],
+                planningPath,
+                polymorphicPaths: exports.POLYMORPHIC_ROOT_PATHS,
+                parentStep: streamItemPlan,
+                positionType: rootType,
+                layerPlan: subscriptionEventLayerPlan,
+                selections: selectionSet.selections,
+                resolverEmulation: true,
+            });
+            this.planPending();
         }
         if (this.loc !== null)
             this.loc.pop();
     }
+    getCombinedLayerPlanForLayerPlans(setOfParentLayerPlans) {
+        const parentLayerPlans = [...setOfParentLayerPlans];
+        // See if one already exists with the same layer plans in the same order
+        for (const lp of this.stepTracker.layerPlans) {
+            if (lp?.reason.type === "combined" &&
+                (0, utils_js_1.arraysMatch)(parentLayerPlans, lp.reason.parentLayerPlans)) {
+                return lp;
+            }
+        }
+        return new LayerPlan_js_1.LayerPlan(this, {
+            type: "combined",
+            parentLayerPlans,
+        });
+    }
     /**
      * 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, stream) {
-        const itemStepId = this.itemStepIdByListStepId[listStep.id];
+    itemStepForListStep(parentLayerPlan, planningPath, listStep, depth, stream) {
+        const itemStepIdByListStepId = (this.itemStepIdByListStepIdByParentLayerPlanId[parentLayerPlan.id] ??=
+            Object.create(null));
+        const itemStepId = itemStepIdByListStepId[listStep.id];
         if (itemStepId !== undefined) {
-            return this.stepTracker.getStepById(itemStepId);
+            const itemStep = this.stepTracker.getStepById(itemStepId);
+            if (listStep.polymorphicPaths !== null &&
+                itemStep.polymorphicPaths !== null) {
+                for (const p of listStep.polymorphicPaths) {
+                    itemStep.polymorphicPaths.add(p);
+                }
+            }
+            return itemStep;
         }
         // Create a new LayerPlan for this list item
-        const layerPlan = new LayerPlan_js_1.LayerPlan(this, parentLayerPlan, {
+        const layerPlan = new LayerPlan_js_1.LayerPlan(this, {
             type: "listItem",
+            parentLayerPlan,
             parentStep: listStep,
             stream,
         });
-        const itemPlan = (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(layerPlan, listStep.polymorphicPaths, () => new index_js_1.__ItemStep(listStep, depth));
-        layerPlan.setRootStep(itemPlan);
-        this.itemStepIdByListStepId[listStep.id] = itemPlan.id;
-        return itemPlan;
-    }
-    processGroupedFieldSet(
-    // Deliberately shadows
-    outputPlan, path, polymorphicPath, polymorphicPaths, parentStep, objectType, objectTypeFields, isMutation, groupedFieldSet) {
+        const itemStep = (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(layerPlan, listStep.polymorphicPaths, planningPath, () => new index_js_1.__ItemStep(listStep, depth));
+        layerPlan.setRootStep(itemStep);
+        itemStepIdByListStepId[listStep.id] = itemStep.id;
+        return itemStep;
+    }
+    *processGroupedFieldSet(details) {
+        const { outputPlan, path, planningPath, polymorphicPaths, parentStep, positionType: objectType, 
+        // layerPlan,
+        objectTypeFields, isMutation, groupedFieldSet, } = details;
         // `__typename` shouldn't bump the mutation index since it has no side effects.
         let mutationIndex = -1;
         const $sideEffect = outputPlan.layerPlan.latestSideEffectStep;
@@ -600,13 +691,12 @@ class OperationPlan {
                 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
+                // 2. we're emulating resolvers
                 const resolver = resolvedResolver && !usesDefaultResolver
                     ? resolvedResolver
-                    : resolverEmulation && isPolymorphic
+                    : resolverEmulation
                         ? defaultFieldResolver
                         : null;
                 // Apply a default plan to fields that do not have a plan nor a resolver.
@@ -683,16 +773,18 @@ class OperationPlan {
                 let step;
                 let haltTree = false;
                 const fieldLayerPlan = isMutation
-                    ? new LayerPlan_js_1.LayerPlan(this, outputPlan.layerPlan, {
+                    ? new LayerPlan_js_1.LayerPlan(this, {
                         type: "mutationField",
+                        parentLayerPlan: outputPlan.layerPlan,
                         mutationIndex: ++mutationIndex,
                     })
                     : outputPlan.layerPlan;
                 const objectFieldArgs = objectField.args;
+                const fieldPath = [...path, responseKey];
+                const fieldPlanningPath = planningPath + responseKey;
                 const trackedArguments = objectFieldArgs.length > 0
-                    ? (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(this.rootLayerPlan, exports.POLYMORPHIC_ROOT_PATHS, this.getTrackedArguments, this, objectFieldArgs, field)
+                    ? (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(this.rootLayerPlan, exports.POLYMORPHIC_ROOT_PATHS, fieldPlanningPath, this.getTrackedArguments, this, objectFieldArgs, field)
                     : NO_ARGS;
-                const fieldPath = [...path, responseKey];
                 let streamDetails = null;
                 const isList = isListType(getNullableType(fieldType));
                 if (isList) {
@@ -735,7 +827,20 @@ class OperationPlan {
                     }
                 }
                 if (typeof planResolver === "function") {
-                    ({ step, haltTree } = this.planField(objectType.name, fieldName, fieldLayerPlan, fieldPath, polymorphicPaths, planResolver, "plan", parentStep, objectField, trackedArguments, isList ? (streamDetails ?? false) : null));
+                    ({ step, haltTree } = yield this.batchPlanField({
+                        typeName: objectType.name,
+                        fieldName,
+                        layerPlan: fieldLayerPlan,
+                        path: fieldPath,
+                        polymorphicPaths,
+                        planningPath: fieldPlanningPath,
+                        planResolver,
+                        applyAfterMode: "plan",
+                        rawParentStep: parentStep,
+                        field: objectField,
+                        trackedArguments,
+                        streamDetails: isList ? (streamDetails ?? false) : null,
+                    }));
                 }
                 else {
                     // No plan resolver (or plan resolver fallback) so there must be a
@@ -749,25 +854,21 @@ class OperationPlan {
                     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));
+                    step = (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(fieldLayerPlan, polymorphicPaths, fieldPlanningPath, () => {
+                        const $args = (0, index_js_1.object)(trackedArguments);
                         return (0, graphqlResolver_js_1.graphqlResolver)(resolver, subscriber, step, $args, {
+                            ...this.resolveInfoOperationBase,
                             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) {
+                    // Very similar to this.handlePlanningError. Should probably use it in future.
                     const isNonNull = isNonNullType(fieldType);
                     outputPlan.addChild(objectType, responseKey, {
                         type: "outputPlan",
@@ -777,11 +878,31 @@ class OperationPlan {
                     });
                 }
                 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);
+                    if (index_js_1.isDev && polymorphicPaths) {
+                        const invalid = [...polymorphicPaths].filter((p) => !stepIsValidInPolyPath(step, p));
+                        if (invalid.length > 0) {
+                            throw new Error(`${objectType}.${fieldName} (as ${responseKey}) returned ${step}, but that's not valid in ${invalid.length} out of ${polymorphicPaths.size} of the expected polymorphic paths. Invalid paths: ${invalid}`);
+                        }
+                    }
+                    outputPlan.expectChild(objectType, responseKey);
+                    this.queueNextLayer(this.planFieldReturnType, {
+                        outputPlan,
+                        path: fieldPath,
+                        planningPath: fieldPlanningPath,
+                        polymorphicPaths,
+                        parentStep: step,
+                        positionType: fieldType,
+                        layerPlan: fieldLayerPlan,
+                        // If one field has a selection set, they all have a selection set (guaranteed by validation).
+                        selections: field.selectionSet != null
+                            ? fieldNodes.flatMap((n) => n.selectionSet.selections)
+                            : undefined,
+                        parentObjectType: objectType,
+                        responseKey,
+                        locationDetails,
+                        resolverEmulation,
+                        streamDetails,
+                    });
                 }
             }
             finally {
@@ -790,8 +911,9 @@ class OperationPlan {
         }
         if (groupedFieldSet.deferred !== undefined) {
             for (const deferred of groupedFieldSet.deferred) {
-                const deferredLayerPlan = new LayerPlan_js_1.LayerPlan(this, outputPlan.layerPlan, {
+                const deferredLayerPlan = new LayerPlan_js_1.LayerPlan(this, {
                     type: "defer",
+                    parentLayerPlan: outputPlan.layerPlan,
                     label: deferred.label,
                 });
                 const deferredOutputPlan = new OutputPlan_js_1.OutputPlan(deferredLayerPlan, outputPlan.rootStep, {
@@ -805,7 +927,18 @@ class OperationPlan {
                 const $sideEffect = deferredOutputPlan.layerPlan.latestSideEffectStep;
                 try {
                     outputPlan.deferredOutputPlans.push(deferredOutputPlan);
-                    this.processGroupedFieldSet(deferredOutputPlan, path, polymorphicPath, polymorphicPaths, parentStep, objectType, objectTypeFields, isMutation, deferred);
+                    this.queueNextLayer(this.processGroupedFieldSet, {
+                        outputPlan: deferredOutputPlan,
+                        path,
+                        planningPath: planningPath + "#",
+                        polymorphicPaths,
+                        parentStep,
+                        positionType: objectType,
+                        layerPlan: deferredLayerPlan,
+                        objectTypeFields,
+                        isMutation,
+                        groupedFieldSet: deferred,
+                    });
                 }
                 finally {
                     deferredOutputPlan.layerPlan.latestSideEffectStep = $sideEffect;
@@ -822,33 +955,432 @@ 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, resolverEmulation, isMutation = false) {
+    planSelectionSet(details) {
+        const { outputPlan, path, planningPath, polymorphicPaths, parentStep, positionType: objectType, layerPlan, selections, resolverEmulation, isMutation = false, } = details;
         if (this.loc !== null) {
-            this.loc.push(`planSelectionSet(${objectType.name} @ ${outputPlan.layerPlan.id} @ ${path.join(".")} @ ${polymorphicPath ?? ""})`);
+            this.loc.push(`planSelectionSet(${objectType.name} @ ${outputPlan.layerPlan.id} @ ${path.join(".")} @ ${polymorphicPaths ? [...polymorphicPaths] : ""})`);
         }
         if (index_js_1.isDev) {
             assertObjectType(objectType);
+            if (outputPlan.layerPlan !== layerPlan) {
+                throw new Error(`GrafastInternalError<3ea1a3dd-1e11-4eb7-a31b-e125996d7eb4>: expected ${outputPlan} to have layer plan ${layerPlan}`);
+            }
         }
-        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 groupedFieldSet = (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(layerPlan, polymorphicPaths, planningPath, 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);
+        this.queueNextLayer(this.processGroupedFieldSet, {
+            outputPlan,
+            path,
+            planningPath: planningPath + ">",
+            polymorphicPaths,
+            parentStep,
+            positionType: objectType,
+            layerPlan,
+            objectTypeFields,
+            isMutation,
+            groupedFieldSet,
+        });
         if (this.loc !== null)
             this.loc.pop();
     }
+    queueNextLayer(method, details) {
+        const { planningPath } = details;
+        if (this.frozenPlanningPaths?.has(planningPath)) {
+            throw new Error(`GrafastInternalError<93c64f55-4f3f-442f-a17b-391e28bd3629>: Already processed planning path ${planningPath}`);
+        }
+        let list = this.planningQueueByPlanningPath.get(planningPath);
+        if (!list) {
+            list = [];
+            this.planningQueueByPlanningPath.set(planningPath, list);
+        }
+        const tuple = [
+            method,
+            details,
+            this.loc ? [...this.loc] : null,
+            details.layerPlan,
+            details.layerPlan.latestSideEffectStep,
+        ];
+        this.planningQueue.push(tuple);
+        list.push(tuple);
+    }
+    planPending() {
+        for (let depth = 0; depth <= this.maxPlanningDepth; depth++) {
+            // Process the next batch
+            const l = this.planningQueue.length;
+            if (l === 0)
+                break;
+            if (depth === this.maxPlanningDepth) {
+                throw new Error(`Query is too complex, Grafast refuses to continue processing at planning depth ${this.maxPlanningDepth}. You can configure this through \`preset.grafast.maxPlanningDepth\``);
+            }
+            // NOTE: `batch` and `todo` are different views of the same information,
+            // specifically: `batch` is stored in the order in which the calls were
+            // made (critical for ensuring the OutputPlans output fields in the
+            // correct order); whereas `todo` is the result of grouping `batch` into
+            // groups where the planning paths match.
+            const batch = this.planningQueue.slice(0, l);
+            const todo = [...this.planningQueueByPlanningPath.entries()];
+            // Now clear the stores ready to start collecting the next lot.
+            this.planningQueue.length = 0;
+            this.planningQueueByPlanningPath.clear();
+            // First, do a planning-path-aware deduplicate
+            this.deduplicateSteps();
+            // Update the step references (and freeze the paths)
+            for (const [planningPath, batch] of todo) {
+                if (this.frozenPlanningPaths?.has(planningPath)) {
+                    throw new Error(`GrafastInternalError<dd30288e-9375-4025-91a6-66b64e74cf74>: planning path already processed - ${planningPath}`);
+                }
+                this.frozenPlanningPaths?.add(planningPath);
+                for (const entry of batch) {
+                    const step = entry[1].parentStep;
+                    const actualStep = this.stepTracker.getStepById(step.id);
+                    if (actualStep !== step) {
+                        entry[1].parentStep = actualStep;
+                    }
+                }
+            }
+            // Then, apply the per-method batch tweaks (such as resolving
+            // polymorphism)
+            this.mutateTodos(todo);
+            const DONE = Symbol("done");
+            const gennies = [];
+            // Finally plan this layer
+            for (const [fn, rawDetails, loc, originalLayerPlan, layerPlanLatestSideEffect,] of batch) {
+                const details = rawDetails;
+                this.withLocLpSE(loc, originalLayerPlan, layerPlanLatestSideEffect, () => {
+                    /** Still just genny from the block */
+                    const genny = fn.call(this, details);
+                    if (genny != null) {
+                        gennies.push({
+                            genny,
+                            loc,
+                            layerPlan: details.layerPlan,
+                            layerPlanLatestSideEffect: details.layerPlan.latestSideEffectStep,
+                            result: undefined,
+                        });
+                    }
+                });
+            }
+            // And go through all the generators
+            while (gennies.length > 0) {
+                const cbs = [];
+                for (const spec of gennies) {
+                    const { genny, loc, layerPlan, layerPlanLatestSideEffect, result } = spec;
+                    this.withLocLpSE(loc, layerPlan, layerPlanLatestSideEffect, () => {
+                        const r = genny.next(result);
+                        if (r.done) {
+                            spec.result = DONE;
+                        }
+                        else {
+                            cbs.push({ spec, cb: r.value });
+                        }
+                    });
+                }
+                for (const { spec, cb } of cbs) {
+                    spec.result = cb();
+                }
+                // Remove the generators that are done.
+                for (let i = gennies.length - 1; i >= 0; i--) {
+                    if (gennies[i].result === DONE) {
+                        gennies.splice(i, 1);
+                    }
+                }
+            }
+        }
+        // A final deduplicate
+        this.deduplicateSteps();
+    }
+    withLocLpSE(loc, layerPlan, layerPlanLatestSideEffect, cb) {
+        const $sideEffect = layerPlan.latestSideEffectStep;
+        layerPlan.latestSideEffectStep = layerPlanLatestSideEffect;
+        try {
+            const prevLoc = this.loc;
+            this.loc = loc;
+            cb();
+            this.loc = prevLoc;
+        }
+        finally {
+            layerPlan.latestSideEffectStep = $sideEffect;
+        }
+    }
+    mutateTodos(todo) {
+        for (const [_planningPath, batch] of todo) {
+            const polymorphicResolveTypeEntriesByPolyType = new Map();
+            const planFieldReturnTypeEntriesByStepByLayerPlan = new Map();
+            for (const entry of batch) {
+                const [method, rawArgs] = entry;
+                // Tidy up after dedupe
+                rawArgs.parentStep = this.stepTracker.getStepById(rawArgs.parentStep.id);
+                if (method === this.polymorphicResolveType) {
+                    const args = rawArgs;
+                    const polyType = args.positionType;
+                    if (!isUnionType(polyType) && !isInterfaceType(polyType)) {
+                        throw new Error(`GrafastInternalError<b0a276d0-134f-4a26-9c33-00af5ead38e6>: expected ${polyType} to be an interface or union type`);
+                    }
+                    let list = polymorphicResolveTypeEntriesByPolyType.get(polyType);
+                    if (!list) {
+                        list = [];
+                        polymorphicResolveTypeEntriesByPolyType.set(polyType, list);
+                    }
+                    list.push(args);
+                }
+                else if (method == this.polymorphicPlanObjectType) {
+                    const args = rawArgs;
+                    const lp = args.layerPlan;
+                    let planFieldReturnTypeEntriesByStep = planFieldReturnTypeEntriesByStepByLayerPlan.get(lp);
+                    if (!planFieldReturnTypeEntriesByStep) {
+                        planFieldReturnTypeEntriesByStep = new Map();
+                        planFieldReturnTypeEntriesByStepByLayerPlan.set(lp, planFieldReturnTypeEntriesByStep);
+                    }
+                    const step = args.parentStep;
+                    let list = planFieldReturnTypeEntriesByStep.get(step);
+                    if (list) {
+                        list.push(args);
+                    }
+                    else {
+                        list = [args];
+                        planFieldReturnTypeEntriesByStep.set(step, list);
+                    }
+                }
+            }
+            // Handle calls to `polymorphicResolveType` by performing the combined
+            // layer plan / `planType` shuffle.
+            for (const [graphqlType, 
+            // A list of all the `details` argument objects capture for this type
+            detailsRecordList,] of polymorphicResolveTypeEntriesByPolyType) {
+                const firstDetailsRecord = detailsRecordList[0];
+                // All of these properties should be in common
+                // const path = firstDetailsRecord.path;
+                const planningPath = firstDetailsRecord.planningPath;
+                const allPossibleObjectTypes = firstDetailsRecord.allPossibleObjectTypes;
+                // The existence of this is common (i.e. either all have it set, or all
+                // have it null, but the actual contents may differ)
+                const polymorphicPaths = firstDetailsRecord.polymorphicPaths;
+                const combinedPolymorphicPaths = polymorphicPaths
+                    ? new Set( /* Populated below */)
+                    : null;
+                let commonLayerPlan;
+                let $original;
+                let commonStep;
+                const steps = new Set(detailsRecordList.map((t) => t.parentStep));
+                if (steps.size > 1) {
+                    $original = null;
+                    // Make combined
+                    const layerPlans = new Set(detailsRecordList.map((t) => t.layerPlan));
+                    const combinedLayerPlan = this.getCombinedLayerPlanForLayerPlans(layerPlans);
+                    const toCombine = [];
+                    let isUnary = true;
+                    for (const detailsRecord of detailsRecordList) {
+                        const parentStep = detailsRecord.parentStep;
+                        const polymorphicPaths = detailsRecord.polymorphicPaths;
+                        const layerPlan = detailsRecord.layerPlan;
+                        if (!parentStep._isUnary) {
+                            isUnary = false;
+                        }
+                        if (polymorphicPaths) {
+                            for (const path of polymorphicPaths) {
+                                combinedPolymorphicPaths.add(path);
+                            }
+                        }
+                        const $data = graphqlType.extensions?.grafast?.toSpecifier
+                            ? (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(layerPlan, polymorphicPaths, planningPath, graphqlType.extensions.grafast.toSpecifier, graphqlType.extensions.grafast, parentStep)
+                            : (0, step_js_1.stepHasToSpecifier)(parentStep)
+                                ? (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(layerPlan, polymorphicPaths, planningPath, parentStep.toSpecifier, parentStep)
+                                : (0, step_js_1.stepHasToRecord)(parentStep)
+                                    ? (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(layerPlan, polymorphicPaths, planningPath, parentStep.toRecord, parentStep)
+                                    : parentStep;
+                        toCombine.push({ step: $data, layerPlan });
+                    }
+                    // Create a __ValueStep in the new combined layer plan that
+                    // represents all of these values
+                    const $combined = (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(combinedLayerPlan, combinedPolymorphicPaths, planningPath, newValueStepCallback, null, false);
+                    if (!isUnary) {
+                        $combined._isUnary = false;
+                    }
+                    // Tell it to populate the __ValuePlan $combined with the combination
+                    // of all the values from toCombine.
+                    combinedLayerPlan.addCombo(toCombine, $combined);
+                    commonLayerPlan = combinedLayerPlan;
+                    commonStep = $combined;
+                }
+                else {
+                    $original = [...steps][0];
+                    const layerPlans = new Set();
+                    for (const tuple of detailsRecordList) {
+                        layerPlans.add(tuple.layerPlan);
+                    }
+                    if (layerPlans.size === 1) {
+                        commonLayerPlan = [...layerPlans][0];
+                    }
+                    else {
+                        commonLayerPlan =
+                            this.getCombinedLayerPlanForLayerPlans(layerPlans);
+                    }
+                    commonStep = graphqlType.extensions?.grafast?.toSpecifier
+                        ? (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(commonLayerPlan, polymorphicPaths, planningPath, graphqlType.extensions.grafast.toSpecifier, graphqlType.extensions.grafast, $original)
+                        : (0, step_js_1.stepHasToSpecifier)($original)
+                            ? (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(commonLayerPlan, polymorphicPaths, planningPath, $original.toSpecifier, $original)
+                            : (0, step_js_1.stepHasToRecord)($original)
+                                ? (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(commonLayerPlan, polymorphicPaths, planningPath, $original.toRecord, $original)
+                                : $original;
+                    for (const detailsRecord of detailsRecordList) {
+                        detailsRecord.layerPlan = commonLayerPlan;
+                        const polymorphicPaths = detailsRecord.polymorphicPaths;
+                        if (polymorphicPaths) {
+                            for (const path of polymorphicPaths) {
+                                combinedPolymorphicPaths.add(path);
+                            }
+                        }
+                    }
+                }
+                // Call planTypes and plan each of the types?
+                const planType = graphqlType.extensions?.grafast?.planType ?? defaultPlanType;
+                // TODO: revisit this. If planType exists then no need? If resolver emulation then always?
+                const resolverEmulation = 
+                // detailsRecordList.some((a) => a.resolverEmulation) && (
+                graphqlType.resolveType != null ||
+                    allPossibleObjectTypes.some((t) => t.isTypeOf != null);
+                const info = {
+                    abstractType: graphqlType,
+                    resolverEmulation,
+                    $original,
+                };
+                let polymorphicTypePlanner;
+                try {
+                    polymorphicTypePlanner = (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(commonLayerPlan, combinedPolymorphicPaths, planningPath, planType, null, commonStep, info);
+                }
+                catch (err) {
+                    const $error = this.withRootLayerPlan(() => (0, index_js_1.error)(err));
+                    polymorphicTypePlanner = {
+                        $__typename: $error,
+                    };
+                }
+                const stepForType = new Map();
+                const allTypeNames = allPossibleObjectTypes.map((t) => t.name);
+                const basePaths = [...(combinedPolymorphicPaths ?? [""])];
+                const polymorphicLayerPlan = new LayerPlan_js_1.LayerPlan(this, {
+                    type: "polymorphic",
+                    parentLayerPlan: commonLayerPlan,
+                    polymorphicPaths: new Set(
+                    // BUG: this isn't 100% correct, it's possible that this layer
+                    // plan might not be used in some of these polymorphic paths (e.g.
+                    // if fragment types caused certain fields to not be selected in
+                    // certain scenarios). We should instead figure out the concrete
+                    // list of polymorphic paths actually seen during planning.
+                    allTypeNames.flatMap((t) => basePaths.map((p) => `${p}>${t}`))),
+                    typeNames: allTypeNames,
+                    parentStep: polymorphicTypePlanner.$__typename,
+                });
+                for (const type of allPossibleObjectTypes) {
+                    const polymorphicPaths = new Set(basePaths.map((p) => `${p}>${type.name}`));
+                    try {
+                        const $stepForType = (polymorphicTypePlanner.planForType
+                            ? (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(polymorphicLayerPlan, polymorphicPaths, planningPath + "?", polymorphicTypePlanner.planForType, polymorphicTypePlanner, type)
+                            : type.extensions?.grafast?.planType
+                                ? (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(polymorphicLayerPlan, polymorphicPaths, planningPath + "?", type.extensions.grafast.planType, type.extensions.grafast, commonStep)
+                                : commonStep) ??
+                            (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(polymorphicLayerPlan, polymorphicPaths, planningPath + "?", constant_js_1.constant, null, index_js_1.$$inhibit);
+                        stepForType.set(type, $stepForType);
+                        if (index_js_1.isDev) {
+                            // Check that this plan is compatible with every poly path
+                            if ($stepForType.polymorphicPaths === null) {
+                                // All good, valid in all paths
+                            }
+                            else {
+                                const missedPaths = [...polymorphicPaths].filter((p) => !stepIsValidInPolyPath($stepForType, p));
+                                if (missedPaths.length > 0) {
+                                    throw new Error(`When planning ${graphqlType}'s planForType for ${type.name}, returned step ${$stepForType} is not valid in ${missedPaths.length} out of ${polymorphicPaths.size} expected paths; missed paths: ${missedPaths}`);
+                                }
+                            }
+                        }
+                    }
+                    catch (e) {
+                        stepForType.set(type, e);
+                    }
+                }
+                // Now replace references to layer plan and step
+                for (const detailsRecord of detailsRecordList) {
+                    detailsRecord.parentStep = commonStep;
+                    detailsRecord.layerPlan = polymorphicLayerPlan;
+                    // TODO: do we want to set the polymorphic paths here or not?
+                    // detailsRecord.polymorphicPaths = combinedPolymorphicPaths;
+                    const { locationDetails, parentObjectType, responseKey, isNonNull, outputPlan: parentOutputPlan, } = detailsRecord;
+                    const polymorphicOutputPlan = new OutputPlan_js_1.OutputPlan(commonLayerPlan, polymorphicTypePlanner.$__typename, {
+                        mode: "polymorphic",
+                        deferLabel: undefined,
+                        typeNames: allPossibleObjectTypes.map((t) => t.name),
+                    }, locationDetails);
+                    detailsRecord.outputPlan = polymorphicOutputPlan;
+                    parentOutputPlan.addChild(parentObjectType, responseKey, {
+                        type: "outputPlan",
+                        outputPlan: polymorphicOutputPlan,
+                        isNonNull,
+                        locationDetails,
+                    });
+                    detailsRecord.stepForType = stepForType;
+                }
+            }
+            for (const [parentLayerPlan, planFieldReturnTypeEntriesByStep,] of planFieldReturnTypeEntriesByStepByLayerPlan) {
+                if (planFieldReturnTypeEntriesByStep.size <= 1) {
+                    continue;
+                }
+                for (const [step, entries] of planFieldReturnTypeEntriesByStep) {
+                    // We already know the planningPath lines up.
+                    // We know all `entries` resolved to the same `step`.
+                    // We know all `entries` come from the same layer plan.
+                    // TODO: I'm not sure if we care if the field result type is the
+                    // same or not. I don't think so?
+                    // We want to create a polymorphicPartition layer plan for these, if
+                    // it makes sense.
+                    // It makes sense if there are multiple different groups; which we
+                    // checked in the `if` above. So, yes.
+                    // TODO: Check assumption: the different groups should relate to
+                    // different types.
+                    const typeNameSet = new Set();
+                    entries.forEach((e) => void typeNameSet.add(e.positionType.name));
+                    const typeNames = [...typeNameSet];
+                    // TODO: eliminate this
+                    const polymorphicPaths = new Set(entries.flatMap((e) => [...(e.polymorphicPaths ?? [])]));
+                    const partitionedLayerPlan = parentLayerPlan.getPartition(typeNames, polymorphicPaths);
+                    /**
+                     * Moves all the steps that match these polymorphic paths only into
+                     * the polymorphicPartition layer plan
+                     */
+                    const recursivelyMoveSteps = (step) => {
+                        if (step.layerPlan !== parentLayerPlan)
+                            return;
+                        if (!(0, utils_js_1.setsMatch)(step.polymorphicPaths, polymorphicPaths))
+                            return;
+                        this.stepTracker.moveStepToLayerPlan(step, partitionedLayerPlan);
+                        for (const dep of (0, utils_js_1.sudo)(step).dependencies) {
+                            recursivelyMoveSteps(dep);
+                        }
+                    };
+                    recursivelyMoveSteps(step);
+                    // TODO: Do we need to update the outputPlan.layerPlan too?
+                    for (const entry of entries) {
+                        entry.layerPlan = partitionedLayerPlan;
+                    }
+                }
+            }
+        }
+    }
     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, resolverEmulation, listDepth, streamDetails) {
+    planFieldReturnType(details) {
+        return this.planIntoOutputPlan({ ...details, listDepth: 0 });
+    }
+    planIntoOutputPlan(details) {
+        const { outputPlan: parentOutputPlan, path, planningPath, polymorphicPaths, parentStep: $step, positionType: fieldType, layerPlan: parentLayerPlan, selections, parentObjectType, responseKey, locationDetails, resolverEmulation, listDepth, streamDetails, } = details;
         const nullableFieldType = getNullableType(fieldType);
         const isNonNull = nullableFieldType !== fieldType;
         if (isListType(nullableFieldType)) {
-            const $list = (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(parentLayerPlan, polymorphicPaths, connection_js_1.itemsOrStep, null, $step);
+            const listItemPlanningPath = planningPath +
+                `[${streamDetails
+                    ? `#${streamDetails.initialCount.id}|${streamDetails.if.id}|${streamDetails.label.id}`
+                    : ""}]`;
+            const $list = (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(parentLayerPlan, polymorphicPaths, listItemPlanningPath, connection_js_1.itemsOrStep, null, $step);
             if ($list !== $step) {
                 $list._stepOptions.stream = $step._stepOptions.stream;
             }
@@ -868,25 +1400,20 @@ class OperationPlan {
                     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;
-            }
+            this.queueNextLayer(this.planListItem, {
+                outputPlan: listOutputPlan,
+                path,
+                planningPath: listItemPlanningPath,
+                polymorphicPaths,
+                parentStep: $list,
+                positionType: nullableFieldType,
+                layerPlan: parentLayerPlan,
+                selections,
+                listDepth,
+                stream,
+                locationDetails,
+                resolverEmulation,
+            });
         }
         else if (isScalarType(nullableFieldType)) {
             const scalarPlanResolver = nullableFieldType.extensions?.grafast?.plan;
@@ -895,7 +1422,7 @@ class OperationPlan {
             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)
+                    ? (0, utils_js_1.assertNotPromise)((0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(parentLayerPlan, polymorphicPaths, planningPath, scalarPlanResolver, null, $step, this.scalarPlanInfo), scalarPlanResolver, fnDescription)
                     : $step;
                 parentOutputPlan.addChild(parentObjectType, responseKey, {
                     type: "outputPlan",
@@ -968,8 +1495,9 @@ class OperationPlan {
                     objectLayerPlan = match;
                 }
                 else {
-                    objectLayerPlan = new LayerPlan_js_1.LayerPlan(this, parentLayerPlan, {
+                    objectLayerPlan = new LayerPlan_js_1.LayerPlan(this, {
                         type: "nullableBoundary",
+                        parentLayerPlan,
                         parentStep: $step,
                     });
                     objectLayerPlan.setRootStep($step);
@@ -988,7 +1516,17 @@ class OperationPlan {
                     isNonNull,
                     locationDetails,
                 });
-                this.planSelectionSet(objectOutputPlan, path, polymorphicPath, polymorphicPaths, $step, nullableFieldType, selections, resolverEmulation);
+                this.queueNextLayer(this.planSelectionSet, {
+                    outputPlan: objectOutputPlan,
+                    path,
+                    planningPath: planningPath + ".",
+                    polymorphicPaths,
+                    parentStep: $step,
+                    positionType: nullableFieldType,
+                    layerPlan: objectLayerPlan,
+                    selections: selections,
+                    resolverEmulation,
+                });
             }
             finally {
                 objectLayerPlan.latestSideEffectStep = $sideEffect;
@@ -999,7 +1537,8 @@ class OperationPlan {
             const isUnion = isUnionType(nullableFieldType);
             const isInterface = isInterfaceType(nullableFieldType);
             if (!(isUnion || isInterface)) {
-                throw new Error(`GrafastInternalError<a54d6d63-d186-4ab9-9299-05f817894300>: Wasn't expecting ${nullableFieldType}`);
+                const never = nullableFieldType;
+                throw new Error(`GrafastInternalError<a54d6d63-d186-4ab9-9299-05f817894300>: Wasn't expecting ${never}`);
             }
             assert.ok(selections, "GrafastInternalError<d94e281c-1a10-463e-b7f5-2b0a3665d99b>: A polymorphic type with no selections is invalid");
             /*
@@ -1007,10 +1546,11 @@ class OperationPlan {
              * other types.
              *
              * First, we figure out the list of `possibleTypes` based on the
-             * union/interface and any other constraints that we know. NOTE: we can't
+             * union/interface and any other constraints that we know. Note: we can't
              * discount a type just because it doesn't have any fragments that apply
              * to it - instead we must still plan an empty selection set (or one just
-             * using `{__typename}`), and we need to know it exists for that. See
+             * using `{__typename}`), and we need to know it exists (is not null) for
+             * that. See
              * https://github.com/graphql/graphql-spec/issues/951#issuecomment-1140957685
              */
             const allPossibleObjectTypes = isUnion
@@ -1027,139 +1567,329 @@ class OperationPlan {
                 });
             }
             else {
-                /*
-                 * Next, we ensure we're dealing with a polymorphic step.
-                 */
-                if (!(0, step_js_1.isPolymorphicStep)($step)) {
-                    throw new Error(`${$step} is not a polymorphic capable step, it must have a planForType method`);
-                }
-                /*
-                 * An output plan for it (knows how to branch the different object
-                 * output plans).
-                 */
-                const polymorphicOutputPlan = new OutputPlan_js_1.OutputPlan(parentLayerPlan, $step, {
-                    mode: "polymorphic",
-                    deferLabel: undefined,
-                    typeNames: allPossibleObjectTypes.map((t) => t.name),
-                }, locationDetails);
-                parentOutputPlan.addChild(parentObjectType, responseKey, {
-                    type: "outputPlan",
-                    outputPlan: polymorphicOutputPlan,
-                    isNonNull,
+                const polymorphicResolvePlanningPath = planningPath + "<*>";
+                this.queueNextLayer(this.polymorphicResolveType, {
+                    outputPlan: parentOutputPlan,
+                    path,
+                    planningPath: polymorphicResolvePlanningPath,
+                    polymorphicPaths,
+                    parentStep: $step, // NOTE: This may be batched and turned into a $specifier step
+                    positionType: nullableFieldType,
+                    layerPlan: parentLayerPlan, // NOTE: This may be batched and turned into a combined layer plan
+                    selections,
+                    allPossibleObjectTypes,
                     locationDetails,
+                    parentObjectType,
+                    responseKey,
+                    isNonNull,
+                    resolverEmulation,
                 });
-                /*
-                 * Now a polymorphic layer plan for all the plans to live in
-                 */
-                const polymorphicLayerPlan = this.getPolymorphicLayerPlan(parentLayerPlan, path, $step, allPossibleObjectTypes);
-                /*
-                 * Now we need to loop through each type and plan it.
-                 */
-                const polyBase = polymorphicPath ?? "";
-                const $oldStep = $step;
-                for (const type of allPossibleObjectTypes) {
-                    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,
-                        });
+            }
+        }
+    }
+    /** @internal */
+    planListItem(details) {
+        const { outputPlan: listOutputPlan, path, planningPath: listItemPlanningPath, polymorphicPaths, parentStep: $list, positionType: nullableFieldType, layerPlan: parentLayerPlan, selections, listDepth, stream, locationDetails, resolverEmulation, } = details;
+        const $__item = this.itemStepForListStep(parentLayerPlan, listItemPlanningPath, $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, listItemPlanningPath, $list.listItem, $list, $__item);
+            }
+            else {
+                $item = $__item;
+            }
+            this.queueNextLayer(this.planIntoOutputPlan, {
+                outputPlan: listOutputPlan,
+                path,
+                planningPath: listItemPlanningPath + "^",
+                polymorphicPaths,
+                parentStep: $item,
+                positionType: nullableFieldType.ofType,
+                layerPlan: $item.layerPlan,
+                selections,
+                parentObjectType: null,
+                responseKey: null,
+                locationDetails,
+                resolverEmulation,
+                listDepth: listDepth + 1,
+                streamDetails: null,
+            });
+        }
+        catch (err) {
+            this.handlePlanningError({
+                outputPlan: listOutputPlan,
+                layerPlan: $__item.layerPlan,
+                objectType: null,
+                responseKey: null,
+                positionType: nullableFieldType.ofType,
+                locationDetails,
+                err,
+            });
+        }
+        finally {
+            $__item.layerPlan.latestSideEffectStep = $sideEffect;
+        }
+    }
+    handlePlanningError(details) {
+        const { outputPlan, layerPlan, objectType, responseKey, positionType, locationDetails, err, } = details;
+        const step = this.withRootLayerPlan(() => (0, index_js_1.error)(err));
+        const nullableFieldType = getNullableType(positionType);
+        const isNonNull = nullableFieldType !== positionType;
+        outputPlan.addChild(objectType, responseKey, {
+            type: "outputPlan",
+            outputPlan: new OutputPlan_js_1.OutputPlan(layerPlan, step, OUTPUT_PLAN_TYPE_NULL, locationDetails),
+            isNonNull,
+            locationDetails,
+        });
+    }
+    /** @internal */
+    polymorphicResolveType(details) {
+        const { outputPlan, path, planningPath: polymorphicResolvePlanningPath, polymorphicPaths, layerPlan, selections, allPossibleObjectTypes, locationDetails, isNonNull, resolverEmulation, stepForType, } = details;
+        if (!stepForType) {
+            throw new Error("GrafastInternalError<6afce944-f963-470f-8575-0d0420b4c838>: planForType wasn't set!");
+        }
+        if (outputPlan.type.mode !== "polymorphic") {
+            throw new Error(`GrafastInternalError<21de2f87-45c9-42c6-a1a3-c2c0f6e72ccb>: expected a polymorphic output plan`);
+        }
+        const polymorphicOutputPlan = outputPlan;
+        /*
+         * Now we need to loop through each type and plan it.
+         */
+        const polyBases = [...(polymorphicPaths ?? [""])];
+        const polymorphicPlanningPath = polymorphicResolvePlanningPath + "!";
+        for (const type of allPossibleObjectTypes) {
+            const $sideEffect = layerPlan.latestSideEffectStep;
+            try {
+                // Bit of a hack, but saves passing it around through all the arguments
+                const newPolymorphicPaths = new Set();
+                for (const polyBase of polyBases) {
+                    const newPolymorphicPath = `${polyBase}>${type.name}`;
+                    //resolveTypeLayerPlan.reason.polymorphicPaths.add(newPolymorphicPath);
+                    newPolymorphicPaths.add(newPolymorphicPath);
+                }
+                const $root = stepForType.get(type);
+                try {
+                    if ($root == null) {
+                        throw new Error(`${details.positionType}'s planType().planForType(${type}) returned ${$root}`);
                     }
-                    finally {
-                        polymorphicLayerPlan.latestSideEffectStep = $sideEffect;
+                    else if (!($root instanceof index_js_1.Step)) {
+                        throw $root;
                     }
                 }
+                catch (err) {
+                    this.handlePlanningError({
+                        outputPlan: polymorphicOutputPlan,
+                        layerPlan: layerPlan,
+                        objectType: type,
+                        responseKey: null,
+                        positionType: type,
+                        locationDetails,
+                        err,
+                    });
+                    return;
+                }
+                // find all selections compatible with `type`
+                const fieldNodes = (0, graphqlMergeSelectionSets_js_1.fieldSelectionsForType)(this, type, selections);
+                this.queueNextLayer(this.polymorphicPlanObjectType, {
+                    outputPlan: polymorphicOutputPlan,
+                    path,
+                    planningPath: polymorphicPlanningPath,
+                    polymorphicPaths: newPolymorphicPaths,
+                    parentStep: $root,
+                    positionType: type,
+                    layerPlan,
+                    fieldNodes,
+                    locationDetails,
+                    isNonNull,
+                    resolverEmulation,
+                });
+            }
+            finally {
+                layerPlan.latestSideEffectStep = $sideEffect;
             }
         }
     }
-    getPolymorphicLayerPlan(parentLayerPlan, path, $step, allPossibleObjectTypes) {
-        // OPTIMIZE: I added the $step.id to pathString to fix a planning issue; but maybe we can do this without branching?
-        // https://github.com/benjie/crystal/issues/109
-        const pathString = `${path.join("|")}!${$step.id}`;
-        const polymorphicLayerPlanByPath = this.polymorphicLayerPlanByPathByLayerPlan.get(parentLayerPlan) ??
-            new Map();
-        if (polymorphicLayerPlanByPath.size === 0) {
-            this.polymorphicLayerPlanByPathByLayerPlan.set(parentLayerPlan, polymorphicLayerPlanByPath);
+    // Before calling this, all the deduplication in the resolveType layer plan
+    // should have taken place, and for each step that survives, a polymorphic
+    // layer plan matching those relevant types should be created, and passed
+    // through here as `polymorphicLayerPlan`.
+    polymorphicPlanObjectType(details) {
+        const { outputPlan, path, planningPath: polymorphicPlanningPath, polymorphicPaths: newPolymorphicPaths, parentStep: $root, positionType: type, layerPlan: polymorphicLayerPlan, fieldNodes, locationDetails, isNonNull, resolverEmulation, } = details;
+        if (outputPlan.type.mode !== "polymorphic") {
+            throw new Error(`GrafastInternalError<4c8d9d82-6cb2-4712-aa1e-fdd2173a0760>: expected a polymorphic output plan`);
+        }
+        const polymorphicOutputPlan = outputPlan;
+        if (polymorphicLayerPlan.reason.type !== "polymorphic" &&
+            polymorphicLayerPlan.reason.type !== "polymorphicPartition") {
+            // NOTE: when queued, this method will be queued with a different layer
+            // plan, but `planPending` should go through and convert it to the
+            // relevant polymorphic layer plans for us.
+            throw new Error(`GrafastInternalError<877eaa1c-30c9-4526-ada4-3ccce020ee0e>: expected ${polymorphicLayerPlan} to be a polymorphic or polymorphicPartition layer plan`);
+        }
+        const objectOutputPlan = new OutputPlan_js_1.OutputPlan(polymorphicLayerPlan, $root, {
+            mode: "object",
+            deferLabel: undefined,
+            typeName: type.name,
+        }, locationDetails);
+        this.planSelectionSet({
+            outputPlan: objectOutputPlan,
+            path,
+            planningPath: polymorphicPlanningPath + ".",
+            polymorphicPaths: newPolymorphicPaths,
+            parentStep: $root,
+            positionType: type,
+            layerPlan: polymorphicLayerPlan,
+            selections: fieldNodes,
+            resolverEmulation,
+        });
+        polymorphicOutputPlan.addChild(type, null, {
+            type: "outputPlan",
+            isNonNull,
+            outputPlan: objectOutputPlan,
+            locationDetails,
+        });
+    }
+    batchPlanField(batchPlanFieldDetails) {
+        let b;
+        if (this.planFieldBatch != null) {
+            b = this.planFieldBatch;
+        }
+        else {
+            b = this.planFieldBatch = {
+                complete: false,
+                batch: [],
+                results: [],
+            };
         }
-        const prev = polymorphicLayerPlanByPath.get(pathString);
-        if (prev !== undefined) {
-            // NOTE: this is typically hit when you have a polymorphic field inside
-            // another polymorphic field - in these cases rather than having the
-            // polymorphism multiply out, we can aim for fewer polymorphic buckets
-            // keeping the plan simpler (and more efficient).
-            const { stepId, layerPlan } = prev;
-            const stepByStepId = this.stepTracker.getStepById(stepId);
-            const stepBy$stepId = this.stepTracker.getStepById($step.id);
-            if (stepByStepId !== stepBy$stepId) {
-                throw new Error(`GrafastInternalError<e01bdc40-7c89-41c6-8d84-56efa22c872a>: unexpected inconsistency when determining the polymorphic LayerPlan to use (pathString = ${pathString}, ${stepByStepId} (${stepId}) != ${stepBy$stepId} (${$step.id}))`);
+        const myIndex = b.batch.length;
+        b.batch.push(batchPlanFieldDetails);
+        return () => {
+            if (!b.complete) {
+                this.processPlanField(b);
             }
-            for (const t of allPossibleObjectTypes) {
-                if (!layerPlan.reason.typeNames.includes(t.name)) {
-                    // Since we're re-using an existing LayerPlan, we should be careful to
-                    // ensure none of the previous assumptions have been broken.
-                    layerPlan.reason.typeNames.push(t.name);
+            const result = b.results[myIndex];
+            if (result.error) {
+                throw result.error;
+            }
+            return result;
+        };
+    }
+    processPlanField(b) {
+        b.complete = true;
+        this.planFieldBatch = null;
+        const groups = new Map();
+        for (let i = 0, l = b.batch.length; i < l; i++) {
+            const batchPlanFieldDetails = b.batch[i];
+            const { typeName, fieldName, layerPlan, 
+            // path,
+            polymorphicPaths, planningPath, 
+            // planResolver,
+            // applyAfterMode,
+            rawParentStep, 
+            // field,
+            trackedArguments, streamDetails, } = batchPlanFieldDetails;
+            const argsSig = Object.entries(trackedArguments)
+                .map(([key, step]) => `${key}:${step.id}`)
+                .join(",");
+            /**
+             * Our tests don't come up with anywhere where rawParentStep.id needs
+             * incorporation into the signature, but I'm feeling paranoid.
+             */
+            const benjiesParanoia = `[${rawParentStep.id}]`;
+            const signature = `${planningPath}@${layerPlan.id}${benjiesParanoia}=${typeName}.${fieldName}(${argsSig})`;
+            let entry = groups.get(signature);
+            if (!entry) {
+                entry = {
+                    firstDetails: batchPlanFieldDetails,
+                    extraDetails: [{ polymorphicPaths }],
+                    streamDetails,
+                    indexes: [i],
+                };
+                groups.set(signature, entry);
+            }
+            else {
+                if (index_js_1.isDev) {
+                    // Check everything lines up as we would expect
+                    for (const key of Object.keys(batchPlanFieldDetails)) {
+                        const myVal = batchPlanFieldDetails[key];
+                        const first = entry.firstDetails[key];
+                        if (myVal === first)
+                            continue;
+                        switch (key) {
+                            case "typeName":
+                                throw new Error(`GraphileInternalError<15e09f3f-1a83-48a8-822c-1158b9740ef7>: processPlanField signature failure - mismatch typeName`);
+                            case "fieldName":
+                                throw new Error(`GraphileInternalError<2999cbf9-7143-4677-9592-0bfc52e12cb0>: processPlanField signature failure - mismatch fieldName`);
+                            case "layerPlan":
+                                throw new Error(`GraphileInternalError<52786d18-cfda-4ed6-a309-9cb31dcd5f34>: processPlanField signature failure - mismatch layerPlan`);
+                            case "path":
+                                if (!(0, utils_js_1.arraysMatch)(batchPlanFieldDetails.path, entry.firstDetails.path)) {
+                                    throw new Error(`GraphileInternalError<cb84829d-ee4c-40cd-a3a6-f53d1029ad83>: processPlanField signature failure - mismatch path`);
+                                }
+                                break;
+                            case "polymorphicPaths":
+                                // Explicitly differences in polymorphicPaths are allowed
+                                break;
+                            case "planningPath":
+                                throw new Error(`GraphileInternalError<1b708215-1549-47c3-9cf5-8fd8d7eb9bd0>: processPlanField signature failure - mismatch planningPath`);
+                            case "planResolver":
+                                throw new Error(`GraphileInternalError<7f14700f-2272-4b6a-a927-7600d934fdf0>: processPlanField signature failure - mismatch planResolver`);
+                            case "applyAfterMode":
+                                throw new Error(`GraphileInternalError<bbddad4f-68aa-49c7-b82c-09ceebf14a3f>: processPlanField signature failure - mismatch applyAfterMode`);
+                            case "rawParentStep":
+                                throw new Error(`GraphileInternalError<3306994d-7881-4495-89d1-6c9252840369>: processPlanField signature failure - mismatch rawParentStep`);
+                            case "field":
+                                throw new Error(`GraphileInternalError<67d2a787-2383-4228-8358-6ea9b3321445>: processPlanField signature failure - mismatch field`);
+                            case "trackedArguments":
+                                if (!(0, utils_js_1.recordsMatch)(batchPlanFieldDetails.trackedArguments, entry.firstDetails.trackedArguments)) {
+                                    throw new Error(`GraphileInternalError<ec3f1e44-0ab6-445c-a644-a4d276f4b787>: processPlanField signature failure - mismatch trackedArguments`);
+                                }
+                                break;
+                            case "streamDetails":
+                                // If any of them don't stream, turn streaming off
+                                if (!streamDetails) {
+                                    entry.streamDetails = null;
+                                }
+                                break;
+                            default: {
+                                const never = key;
+                                throw new Error(`GraphileInternalError<3f039c33-0b43-47d8-8da8-57873186cd60>: unexpected key '${never}'`);
+                            }
+                        }
+                    }
                 }
+                entry.indexes.push(i);
+                entry.extraDetails.push({ polymorphicPaths });
+            }
+        }
+        // Loop through the groups and resolve the plan ONCE per group.
+        // We don't care about the signature here; that was just for grouping
+        for (const entry of groups.values()) {
+            const planFieldDetails = {
+                ...entry.firstDetails,
+                polymorphicPaths: entry.firstDetails.polymorphicPaths
+                    ? new Set([
+                        ...entry.firstDetails.polymorphicPaths,
+                        ...entry.extraDetails.flatMap((d) => [...d.polymorphicPaths]),
+                    ])
+                    : null,
+            };
+            let result;
+            try {
+                result = this._realPlanField(planFieldDetails);
+            }
+            catch (error) {
+                result = { error };
+            }
+            for (const i of entry.indexes) {
+                b.results[i] = result;
             }
-            return layerPlan;
-        }
-        else {
-            const layerPlan = new LayerPlan_js_1.LayerPlan(this, parentLayerPlan, {
-                type: "polymorphic",
-                typeNames: allPossibleObjectTypes.map((t) => t.name),
-                parentStep: $step,
-                polymorphicPaths: new Set(),
-            });
-            polymorphicLayerPlanByPath.set(pathString, {
-                stepId: $step.id,
-                layerPlan,
-            });
-            return layerPlan;
         }
     }
-    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) {
+    _realPlanField(planFieldDetails) {
+        const { typeName, fieldName, layerPlan, path, polymorphicPaths, planningPath, planResolver, applyAfterMode, rawParentStep, field, trackedArguments, streamDetails, } = planFieldDetails;
         const coordinate = `${typeName}.${fieldName}`;
         // The step may have been de-duped whilst sibling steps were planned
         // PERF: this should be handled in the parent?
@@ -1169,7 +1899,7 @@ class OperationPlan {
         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, trackedArguments, field, parentStep, applyAfterMode, coordinate, (fieldArgs) => planResolver(parentStep, fieldArgs, {
+            let step = (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(layerPlan, polymorphicPaths, planningPath, operationPlan_input_js_1.withFieldArgsForArguments, null, this, trackedArguments, field, parentStep, applyAfterMode, coordinate, (fieldArgs) => planResolver(parentStep, fieldArgs, {
                 fieldName,
                 field,
                 schema: this.schema,
@@ -1180,7 +1910,7 @@ class OperationPlan {
                 step =
                     step ||
                         // `withGlobalLayerPlan(layerPlan, polymorphicPaths, () => constant(null))` but with reduced memory allocation
-                        (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(layerPlan, polymorphicPaths, constant_js_1.constant, null, null);
+                        (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(layerPlan, polymorphicPaths, planningPath, constant_js_1.constant, null, null);
                 haltTree = true;
             }
             (0, step_js_1.assertExecutableStep)(step);
@@ -1200,15 +1930,6 @@ class OperationPlan {
                 };
                 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
-                // peers are identical.
-                this.deduplicateSteps();
-                // After deduplication, this step may have been substituted; get the
-                // updated reference.
-                step = this.stepTracker.getStepById(step.id);
-            }
             return { step, haltTree };
         }
         catch (e) {
@@ -1231,7 +1952,7 @@ class OperationPlan {
                 console.error(`Cleanup error occurred whilst trying to recover from field planning error: ${e2.stack}`);
                 throw e;
             }
-            const step = (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(layerPlan, polymorphicPaths, index_js_1.error, null, e);
+            const step = (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(layerPlan, polymorphicPaths, planningPath, index_js_1.error, null, e);
             const haltTree = true;
             // PERF: consider deleting all steps that were allocated during this. For
             // now we'll just rely on tree-shaking.
@@ -1264,18 +1985,14 @@ class OperationPlan {
             const argumentPlan = (0, input_js_1.inputStep)(this, argumentType, argumentValue?.value, defaultValue);
             trackedArgumentValues[argumentName] = argumentPlan;
         }
-        return {
-            get(name) {
-                return trackedArgumentValues[name];
-            },
-        };
+        return trackedArgumentValues;
     }
     /**
      * 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, 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));
+        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];
     }
     /**
@@ -1322,7 +2039,7 @@ class OperationPlan {
                     }
                 }
             }
-            const subroutineLayerPlan = step[interfaces_js_1.$$subroutine];
+            const subroutineLayerPlan = step[constants_js_1.$$subroutine];
             if (subroutineLayerPlan !== null) {
                 const $root = subroutineLayerPlan.rootStep;
                 if ($root) {
@@ -1344,7 +2061,7 @@ class OperationPlan {
         }
         let replacementStep = step;
         try {
-            replacementStep = (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(step.layerPlan, step.polymorphicPaths, callback, this, step);
+            replacementStep = (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(step.layerPlan, step.polymorphicPaths, null, callback, this, step);
         }
         catch (e) {
             console.error(`Error occurred during ${actionDescription}; whilst processing ${step} in ${order} mode an error occurred:`, e);
@@ -1362,7 +2079,9 @@ class OperationPlan {
             if (replacementStep !== step) {
                 this.replaceStep(step, replacementStep);
             }
-            this.deduplicateSteps();
+            if (actionDescription !== "deduplicate") {
+                this.deduplicateSteps();
+            }
         }
         return replacementStep;
     }
@@ -1421,21 +2140,18 @@ class OperationPlan {
             // 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;
-        }
         // 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) {
+            // 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.
             // 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!)
@@ -1446,7 +2162,7 @@ class OperationPlan {
             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 { dependencies: deps, dependencyForbiddenFlags: flags, dependencyOnReject: onReject, dependencyDataOnly: dataOnly, layerPlan: layerPlan, constructor: stepConstructor, peerKey, } = sstep;
         // const streamInitialCount = sstep._stepOptions.stream?.initialCount;
         const dependencyCount = deps.length;
         if (dependencyCount === 0) {
@@ -1455,7 +2171,7 @@ class OperationPlan {
             for (const possiblyPeer of stepsWithNoDependencies) {
                 if (possiblyPeer !== step &&
                     !possiblyPeer.hasSideEffects &&
-                    possiblyPeer.layerPlan === layerPlan &&
+                    isPeerLayerPlan(possiblyPeer.layerPlan, layerPlan) &&
                     possiblyPeer._stepOptions.stream == null &&
                     possiblyPeer.peerKey === peerKey
                 // && possiblyPeer._stepOptions.stream?.initialCount === streamInitialCount
@@ -1472,8 +2188,9 @@ class OperationPlan {
         }
         else if (dependencyCount === 1) {
             // Optimized form for steps that have one dependency (extremely common!)
+            const dependencyIndex = 0;
             const { ancestry, deferBoundaryDepth } = layerPlan;
-            const dep = deps[0];
+            const dep = deps[dependencyIndex];
             const dl = dep.dependents.length;
             if (dl === 1) {
                 // We're the only dependent; therefore we have no peers (since peers
@@ -1483,7 +2200,7 @@ class OperationPlan {
             const minDepth = Math.max(deferBoundaryDepth, dep.layerPlan.depth);
             let allPeers = null;
             for (const { dependencyIndex: peerDependencyIndex, step: rawPossiblyPeer, } of dep.dependents) {
-                if (peerDependencyIndex !== 0 ||
+                if (peerDependencyIndex !== dependencyIndex ||
                     rawPossiblyPeer === step ||
                     rawPossiblyPeer.hasSideEffects ||
                     rawPossiblyPeer._stepOptions.stream != null ||
@@ -1494,12 +2211,13 @@ class OperationPlan {
                     continue;
                 }
                 const possiblyPeer = (0, utils_js_1.sudo)(rawPossiblyPeer);
-                const { layerPlan: peerLayerPlan, dependencyForbiddenFlags: peerFlags, dependencyOnReject: peerOnReject, } = possiblyPeer;
+                const { layerPlan: peerLayerPlan, dependencyForbiddenFlags: peerFlags, dependencyOnReject: peerOnReject, dependencyDataOnly: peerDataOnly, } = possiblyPeer;
                 if (peerLayerPlan.depth >= minDepth &&
                     possiblyPeer.dependencies.length === dependencyCount &&
-                    peerLayerPlan === ancestry[peerLayerPlan.depth] &&
-                    peerFlags[0] === flags[0] &&
-                    peerOnReject[0] === onReject[0]) {
+                    isPeerLayerPlan(peerLayerPlan, ancestry[peerLayerPlan.depth]) &&
+                    peerFlags[dependencyIndex] === flags[dependencyIndex] &&
+                    peerOnReject[dependencyIndex] === onReject[dependencyIndex] &&
+                    peerDataOnly[dependencyIndex] === dataOnly[dependencyIndex]) {
                     if (allPeers === null) {
                         allPeers = [possiblyPeer];
                     }
@@ -1548,11 +2266,12 @@ class OperationPlan {
                             continue;
                         }
                         const possiblyPeer = (0, utils_js_1.sudo)(rawPossiblyPeer);
-                        const { layerPlan: peerLayerPlan, dependencyForbiddenFlags: peerFlags, dependencyOnReject: peerOnReject, dependencies: peerDependencies, } = possiblyPeer;
+                        const { layerPlan: peerLayerPlan, dependencyForbiddenFlags: peerFlags, dependencyOnReject: peerOnReject, dependencyDataOnly: peerDataOnly, dependencies: peerDependencies, } = possiblyPeer;
                         if (peerDependencies.length === dependencyCount &&
-                            peerLayerPlan === ancestry[peerLayerPlan.depth] &&
-                            peerFlags[0] === flags[0] &&
-                            peerOnReject[0] === onReject[0]) {
+                            isPeerLayerPlan(peerLayerPlan, ancestry[peerLayerPlan.depth]) &&
+                            peerFlags[dependencyIndex] === flags[dependencyIndex] &&
+                            peerOnReject[dependencyIndex] === onReject[dependencyIndex] &&
+                            peerDataOnly[dependencyIndex] === dataOnly[dependencyIndex]) {
                             possiblePeers.push(possiblyPeer);
                         }
                     }
@@ -1569,10 +2288,17 @@ class OperationPlan {
             outerloop: for (const possiblyPeer of possiblePeers) {
                 if (possiblyPeer.layerPlan.depth < minDepth)
                     continue;
+                const speer = (0, utils_js_1.sudo)(possiblyPeer);
+                // PERF: I'm not sure we strictly require this.
+                if (!(0, utils_js_1.arraysMatch)(sstep._refs, speer._refs, (refA, refB) => refA === refB ||
+                    this.stepTracker.getStepById(refA) ===
+                        this.stepTracker.getStepById(refB))) {
+                    continue;
+                }
                 // 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] !== (0, utils_js_1.sudo)(possiblyPeer).dependencies[i]) {
+                    if (deps[i] !== speer.dependencies[i]) {
                         continue outerloop;
                     }
                 }
@@ -1593,7 +2319,7 @@ class OperationPlan {
         if (isPrepopulatedStep(step)) {
             return true;
         }
-        if (step[interfaces_js_1.$$subroutine] !== null) {
+        if (step[constants_js_1.$$subroutine] !== null) {
             // Don't hoist steps that are the parent of a subroutine
             // PERF: we _should_ be able to hoist, but care must be taken. Currently it causes test failures.
             return true;
@@ -1620,15 +2346,19 @@ class OperationPlan {
           return true;
         }
         */
-        if (step.layerPlan.parentLayerPlan?.reason.type === "mutationField") {
+        if (step.layerPlan.reason.type === "root") {
+            // There is no higher layerPlan
+            return;
+        }
+        else if (step.layerPlan.reason.type === "combined") {
+            // Cannot hoist out of a combination
+            return;
+        }
+        else if (step.layerPlan.reason.parentLayerPlan.reason.type === "mutationField") {
             // Never hoist into a mutation layer
             return;
         }
         switch (step.layerPlan.reason.type) {
-            case "root": {
-                // There is no higher layerPlan
-                return;
-            }
             case "subscription":
             case "defer": {
                 // Should be deferred, don't evaluate early (unless it's cheap to do so)
@@ -1641,23 +2371,28 @@ class OperationPlan {
                 }
             }
             case "polymorphic": {
-                // May only need to be evaluated for certain types, so avoid hoisting anything expensive.
-                if (step.isSyncAndSafe &&
+                // Only hoist steps that are executed for all the types
+                if (step.polymorphicPaths === null ||
                     step.polymorphicPaths.size ===
                         step.layerPlan.reason.polymorphicPaths.size) {
-                    // It's cheap and covers all types, try and hoist it.
-                    // NOTE: I have concerns about whether this is safe or not, but I
-                    // have not been able to come up with a counterexample that is
-                    // unsafe. Should we do so, we should remove this.
+                    // It covers all types, try and hoist it.
                     break;
                 }
                 else if (step instanceof index_js_1.__FlagStep) {
+                    // Flag step is cheap, try and hoist
                     break;
                 }
                 else {
                     return;
                 }
             }
+            case "polymorphicPartition": {
+                // Don't want to hoist out of a polymorphic partition
+                // TODO: revisit this, e.g. global unary steps should be hoistable? But
+                // we should only do that if they're cheap, we don't want to run
+                // expensive stuff at a higher level if only certain types need it.
+                return;
+            }
             case "subroutine": {
                 // Should be safe to hoist.
                 break;
@@ -1712,51 +2447,31 @@ class OperationPlan {
             return;
         }
         // All our checks passed, hoist it.
-        assert.ok(step.layerPlan.parentLayerPlan !== null, "GrafastInternalError<55c8940f-e8ac-4985-8b34-96fc6f81d62d>: A non-root layer plan had no parent?!");
         // 1: adjust polymorphicPaths to fit new layerPlan
         if (step.layerPlan.reason.type === "polymorphic") {
             // PERF: this is cacheable
-            /** The closest ancestor layer plan that is polymorphic */
-            let ancestor = step.layerPlan;
-            while ((ancestor = ancestor.parentLayerPlan)) {
-                if (ancestor.reason.type === "polymorphic") {
+            let newPolyPaths = new Set();
+            for (const polyPath of step.polymorphicPaths) {
+                const i = polyPath.lastIndexOf(">");
+                if (i > 0) {
+                    const newPath = polyPath.slice(0, i);
+                    newPolyPaths.add(newPath);
+                }
+                else if (i === 0) {
+                    newPolyPaths = null;
                     break;
                 }
-            }
-            const parentPolymorphicPaths = ancestor
-                ? ancestor.reason
-                    .polymorphicPaths
-                : exports.POLYMORPHIC_ROOT_PATHS;
-            const myPaths = [...step.polymorphicPaths];
-            if (parentPolymorphicPaths?.has(myPaths[0])) {
-                // All the others must be valid too
-            }
-            else if (parentPolymorphicPaths === null) {
-                step.polymorphicPaths = null;
-            }
-            else {
-                const layerPaths = [...step.layerPlan.reason.polymorphicPaths];
-                const newPaths = new Set();
-                for (const path of parentPolymorphicPaths) {
-                    const prefix = path + ">";
-                    const matches = myPaths.filter((p) => p.startsWith(prefix));
-                    const layerMatches = layerPaths.filter((p) => p.startsWith(prefix));
-                    if (matches.length !== layerMatches.length) {
-                        // Can't hoist because it's not used for all polymorphicPaths of this type
-                        return;
-                    }
-                    else if (matches.length > 0) {
-                        newPaths.add(path);
-                    }
+                else {
+                    throw new Error(`GrafastInternalError<42f1c7e7-e544-46d2-81b3-00db11eb5def>: invalid poly path ${polyPath}`);
                 }
-                step.polymorphicPaths = newPaths;
             }
+            step.polymorphicPaths = newPolyPaths;
         }
         const $subroutine = step.layerPlan.reason.type === "subroutine"
             ? step.layerPlan.reason.parentStep
             : null;
         // 2: move it up a layer
-        this.stepTracker.moveStepToLayerPlan(step, step.layerPlan.parentLayerPlan);
+        this.stepTracker.moveStepToLayerPlan(step, step.layerPlan.reason.parentLayerPlan);
         // 3: if it's was in a subroutine, the subroutine parent plan needs to list it as a dependency
         if ($subroutine) {
             // Naughty naughty
@@ -1783,12 +2498,16 @@ class OperationPlan {
             case "subscription":
             case "defer":
             case "polymorphic":
+            case "polymorphicPartition":
             case "subroutine":
             case "nullableBoundary":
             case "listItem": {
                 // Fine to push lower
                 break;
             }
+            case "combined": {
+                return step;
+            }
             case "mutationField": {
                 // NOTE: It's the user's responsibility to ensure that steps that have
                 // side effects are marked as such via `step.hasSideEffects = true`.
@@ -1830,11 +2549,24 @@ class OperationPlan {
         const layerPlansByParent = this.stepTracker.layerPlansByParentStep.get(step);
         if (layerPlansByParent !== undefined) {
             for (const layerPlan of layerPlansByParent) {
-                if (layerPlan.parentLayerPlan === step.layerPlan) {
+                if (layerPlan.reason.parentLayerPlan === step.layerPlan) {
                     return step;
                 }
                 else {
-                    dependentLayerPlans.add(layerPlan.parentLayerPlan);
+                    dependentLayerPlans.add(layerPlan.reason.parentLayerPlan);
+                }
+            }
+        }
+        const layerPlansByDependent = this.stepTracker.layerPlansByDependentStep.get(step);
+        if (layerPlansByDependent !== undefined) {
+            for (const layerPlan of layerPlansByDependent) {
+                for (const parentLayerPlan of layerPlan.reason.parentLayerPlans) {
+                    if (parentLayerPlan === step.layerPlan) {
+                        return step;
+                    }
+                    else if ((0, utils_js_1.layerPlanHeirarchyContains)(parentLayerPlan, step.layerPlan)) {
+                        dependentLayerPlans.add(parentLayerPlan);
+                    }
                 }
             }
         }
@@ -1858,28 +2590,30 @@ class OperationPlan {
         const paths = [];
         let minPathLength = Infinity;
         for (const dependentLayerPlan of dependentLayerPlans) {
-            let lp = dependentLayerPlan;
-            const path = [lp];
-            while (lp.parentLayerPlan != step.layerPlan) {
-                const parent = lp.parentLayerPlan;
-                if (!parent) {
-                    throw new Error(`GrafastInternalError<64c07427-4fe2-43c4-9858-272d33bee0b8>: invalid layer plan heirarchy`);
-                }
-                lp = parent;
-                path.push(lp);
+            const lp = dependentLayerPlan;
+            const childPaths = (0, utils_js_1.pathsFromAncestorToTargetLayerPlan)(step.layerPlan, lp);
+            if (childPaths.length === 0) {
+                throw new Error(`GrafastInternalError<64c07427-4fe2-43c4-9858-272d33bee0b8>: invalid layer plan heirarchy; step ${step} cannot be found from ${dependentLayerPlan}`);
+            }
+            for (const path of childPaths) {
+                paths.push(path);
+                minPathLength = Math.min(path.length, minPathLength);
             }
-            paths.push(path);
-            minPathLength = Math.min(path.length, minPathLength);
         }
         const dependentLayerPlanCount = dependentLayerPlans.size;
         let deepest = step.layerPlan;
-        outerloop: for (let i = 0; i < minPathLength; i++) {
+        outerloop: for (let i = minPathLength - 1; i >= 0; i--) {
             const expected = paths[0][i];
             if (expected.reason.type === "polymorphic") {
                 // PERF: reconsider
                 // Let's not pass polymorphic boundaries for now
                 break;
             }
+            if (expected.reason.type === "polymorphicPartition") {
+                // PERF: reconsider
+                // Let's not pass polymorphic boundaries for now
+                break;
+            }
             if (expected.reason.type === "subroutine") {
                 // PERF: reconsider
                 // Let's not pass subroutine boundaries for now
@@ -1974,10 +2708,36 @@ class OperationPlan {
         const winner = stepsAtMinDepth[0];
         if (winner.polymorphicPaths !== null) {
             const polymorphicPaths = new Set();
-            for (const s of stepsAtMinDepth) {
-                for (const p of s.polymorphicPaths) {
-                    polymorphicPaths.add(p);
+            // If the paths don't match up we must be in a polymorphicPartition and
+            // need to move the winner out of it
+            tryAgain: for (let attempts = 0; attempts < 2; attempts++) {
+                const layerPolymorphicPaths = polymorphicPathsForLayer(winner.layerPlan);
+                // PERF: this string trimming is hideous
+                for (const s of [step, ...equivalentSteps]) {
+                    for (const p of s.polymorphicPaths) {
+                        let trimmed = p;
+                        let i;
+                        while (!layerPolymorphicPaths.has(trimmed) &&
+                            (i = trimmed.lastIndexOf(">")) >= 0) {
+                            if (i === 0) {
+                                const reason = winner.layerPlan.reason;
+                                if (reason.type === "polymorphicPartition") {
+                                    // Hoist winner into the polymorphic layer plan, and restart
+                                    // the loop
+                                    this.stepTracker.moveStepToLayerPlan(winner, reason.parentLayerPlan);
+                                    polymorphicPaths.clear();
+                                    continue tryAgain;
+                                }
+                                else {
+                                    throw new Error(`GrafastInternalError<93da1006-3af9-44dd-a54b-5bf6fe3e791c>: ${s} has polymorphic paths ${[...(s.polymorphicPaths ?? [])]}; but ${p} is not in ${[...layerPolymorphicPaths]}.`);
+                                }
+                            }
+                            trimmed = trimmed.slice(0, i);
+                        }
+                        polymorphicPaths.add(trimmed);
+                    }
                 }
+                break;
             }
             winner.polymorphicPaths = polymorphicPaths;
         }
@@ -2041,7 +2801,8 @@ class OperationPlan {
                 this.deduplicateStepsProcess(processed, start, dep);
             }
         }
-        (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(step.layerPlan, step.polymorphicPaths, this.phase === "plan" ? this.deduplicateStep : this.hoistAndDeduplicate, this, step);
+        (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(step.layerPlan, step.polymorphicPaths, null, // TODO: can we get the operation path when phase === "plan"?
+        this.phase === "plan" ? this.deduplicateStep : this.hoistAndDeduplicate, this, step);
     }
     /**
      * Gives us a chance to replace nearly-duplicate plans with other existing
@@ -2054,12 +2815,17 @@ class OperationPlan {
      * former SELECT additional fields, then transform the results back to what
      * our child plans would be expecting.
      */
-    deduplicateSteps(depth = 0) {
+    deduplicateSteps() {
         const start = this.stepTracker.nextStepIdToDeduplicate;
-        const end = this.stepTracker.stepCount;
-        if (end === start) {
+        if (start === this.stepTracker.stepCount) {
+            // No action necessary since there are no new steps
             return;
         }
+        // Then we deduplicate
+        this._deduplicateStepsInner(start, 0);
+    }
+    _deduplicateStepsInner(start, depth) {
+        const end = this.stepTracker.stepCount;
         const processed = new Set();
         for (let i = start; i < end; i++) {
             const step = this.stepTracker.stepById[i];
@@ -2080,7 +2846,7 @@ class OperationPlan {
                     .map((s) => String(s))
                     .join(", ")}.`);
             }
-            return this.deduplicateSteps(depth + 1);
+            return this._deduplicateStepsInner(end, depth + 1);
         }
     }
     hoistAndDeduplicate(step) {
@@ -2204,7 +2970,7 @@ class OperationPlan {
                 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));
+                    const inlineDetails = $flag.inline($dependent._getDepOptions(dependencyIndex));
                     if (inlineDetails === null) {
                         continue flagLoop;
                     }
@@ -2217,11 +2983,13 @@ class OperationPlan {
                 }
                 // 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;
+                    const { $dependent, dependencyIndex, inlineDetails: { onReject, acceptFlags = constants_js_1.DEFAULT_ACCEPT_FLAGS, dataOnly = false, }, } = todo;
                     (0, utils_js_1.writeableArray)($dependent.dependencyOnReject)[dependencyIndex] =
                         onReject;
+                    (0, utils_js_1.writeableArray)($dependent.dependencyDataOnly)[dependencyIndex] =
+                        dataOnly;
                     (0, utils_js_1.writeableArray)($dependent.dependencyForbiddenFlags)[dependencyIndex] =
-                        interfaces_js_1.ALL_FLAGS & ~acceptFlags;
+                        constants_js_1.ALL_FLAGS & ~acceptFlags;
                 }
                 const $flagDep = (0, utils_js_1.sudo)($flag).dependencies[0];
                 this.stepTracker.replaceStep($flag, $flagDep);
@@ -2234,6 +3002,11 @@ class OperationPlan {
         for (const step of this.stepTracker.activeSteps) {
             const wasLocked = index_js_1.isDev && (0, lock_js_1.unlock)(step);
             step.finalize();
+            if (step._stepOptions.stream) {
+                // (Potentially) streamed steps aren't sync and safe, we need to
+                // iterate them expensively
+                step.isSyncAndSafe = false;
+            }
             if (wasLocked)
                 (0, lock_js_1.lock)(step);
             (0, step_js_1.assertFinalized)(step);
@@ -2250,6 +3023,9 @@ class OperationPlan {
         const ensurePlanAvailableInLayer = (dep, layerPlan) => {
             let currentLayerPlan = layerPlan;
             while (dep.layerPlan !== currentLayerPlan) {
+                if (currentLayerPlan.reason.type === "root") {
+                    throw new Error(`GrafastInternalError<7f3ce201-810c-4639-8e69-f44a95221c6d>: reached root whilst ensuring ${dep} is available in ${layerPlan}`);
+                }
                 if (currentLayerPlan.copyStepIds.includes(dep.id)) {
                     break;
                 }
@@ -2261,21 +3037,208 @@ class OperationPlan {
                     targetStep._isUnaryLocked = true;
                 }
                 currentLayerPlan.copyStepIds.push(dep.id);
-                currentLayerPlan = currentLayerPlan.parentLayerPlan;
+                if (currentLayerPlan.reason.type === "combined") {
+                    const prev = currentLayerPlan;
+                    currentLayerPlan = null;
+                    // Figure out which of our parent layer plans contains the step
+                    for (const parentLayerPlan of prev.reason.parentLayerPlans) {
+                        if (dep.layerPlan === parentLayerPlan) {
+                            currentLayerPlan = parentLayerPlan;
+                            break;
+                        }
+                        else if ((0, utils_js_1.layerPlanHeirarchyContains)(parentLayerPlan, dep.layerPlan)) {
+                            ensurePlanAvailableInLayer(dep, parentLayerPlan);
+                        }
+                    }
+                    if (currentLayerPlan == null) {
+                        return;
+                    }
+                }
+                else {
+                    currentLayerPlan = currentLayerPlan.reason.parentLayerPlan;
+                }
                 if (!currentLayerPlan) {
                     throw new Error(`GrafastInternalError<8c1640b9-fa3c-440d-99e5-7693d0d7e5d1>: could not find layer plan for '${dep}' in chain from layer plan ${layerPlan}`);
                 }
             }
         };
+        // Track exactly which steps are in which layer plans
+        const phaseTransitionLayerPlans = new Set();
+        const combinedLayerPlans = new Set();
+        const childrenByLayerPlan = new Map();
+        const addParent = (lp, parent) => {
+            let list = childrenByLayerPlan.get(parent);
+            if (!list) {
+                list = [];
+                childrenByLayerPlan.set(parent, list);
+            }
+            list.push(lp);
+        };
         for (const layerPlan of this.stepTracker.layerPlans) {
             if (!layerPlan) {
                 continue;
             }
+            if ((0, utils_js_1.isPhaseTransitionLayerPlan)(layerPlan)) {
+                phaseTransitionLayerPlans.add(layerPlan);
+            }
+            if (layerPlan.reason.type === "combined") {
+                combinedLayerPlans.add(layerPlan);
+            }
             layerPlan.steps = [];
+            switch (layerPlan.reason.type) {
+                case "root":
+                    break;
+                case "combined": {
+                    for (const parent of layerPlan.reason.parentLayerPlans) {
+                        addParent(layerPlan, parent);
+                    }
+                    break;
+                }
+                default: {
+                    addParent(layerPlan, layerPlan.reason.parentLayerPlan);
+                }
+            }
+        }
+        // Go through all the phase transition layer plans and populate their
+        // "outOfBoundsLayerPlanIds". These are "external inputs" to the subgraph
+        // of layer plans starting at the phase transition layer plan. The external
+        // inputs will always be parent nodes of combined layer plans that are
+        // descendents of the phase transition layer plan.
+        for (const phaseTransitionNode of phaseTransitionLayerPlans) {
+            const descendents = getDescendents(phaseTransitionNode, childrenByLayerPlan);
+            for (const combo of combinedLayerPlans) {
+                if (descendents.has(combo)) {
+                    for (const parent of combo.reason.parentLayerPlans) {
+                        if (!descendents.has(parent)) {
+                            phaseTransitionNode.outOfBoundsLayerPlanIds.add(parent.id);
+                        }
+                    }
+                }
+            }
         }
         for (const step of this.stepTracker.activeSteps) {
             step.layerPlan.steps.push(step);
         }
+        // For each layer plan, track the polymorphic types, and mark the steps in
+        // that layer plan as selective if they don't possess the same number of
+        // poly paths.
+        const polyPathsByLayerPlan = new Map();
+        const processPolymorphicPathsInLayerPlan = (layerPlan) => {
+            const existing = polyPathsByLayerPlan.get(layerPlan);
+            if (existing) {
+                return existing;
+            }
+            const parentPolyPaths = layerPlan.reason.type === "root"
+                ? EMPTY_SET
+                : layerPlan.reason.type === "combined"
+                    ? new Set(layerPlan.reason.parentLayerPlans.flatMap((p) => [
+                        ...processPolymorphicPathsInLayerPlan(p),
+                    ]))
+                    : processPolymorphicPathsInLayerPlan(layerPlan.reason.parentLayerPlan);
+            let polyPaths;
+            const reason = layerPlan.reason;
+            switch (reason.type) {
+                case "root":
+                case "nullableBoundary":
+                case "listItem":
+                case "defer":
+                case "subroutine":
+                case "subscription":
+                case "mutationField": {
+                    polyPaths = parentPolyPaths;
+                    break;
+                }
+                case "combined": {
+                    // Resolve redundant combinations now plans have been deduped/optimized
+                    for (const combo of layerPlan.combinations) {
+                        const { sources } = combo;
+                        let newSources = null;
+                        const l = sources.length;
+                        // Deliberately miss the first (index=0) item
+                        for (let i = l - 1; i > 0; i--) {
+                            const source = sources[i];
+                            const { layerPlanId, stepId } = source;
+                            for (let j = i - 1; j >= 0; j--) {
+                                const otherSource = sources[j];
+                                if (otherSource.layerPlanId === layerPlanId &&
+                                    otherSource.stepId === stepId) {
+                                    if (!newSources)
+                                        newSources = [...sources];
+                                    // Duplicate! Remove it!
+                                    newSources.splice(i, 1);
+                                    break;
+                                }
+                            }
+                        }
+                        if (newSources) {
+                            combo.sources = newSources;
+                        }
+                    }
+                    // Populate our final polyPaths
+                    const newPolyPaths = new Set();
+                    for (const lp of reason.parentLayerPlans) {
+                        const paths = processPolymorphicPathsInLayerPlan(lp);
+                        for (const p of paths) {
+                            newPolyPaths.add(p);
+                        }
+                    }
+                    polyPaths = newPolyPaths;
+                    // Check that everything is sensible
+                    if (index_js_1.isDev) {
+                        // Let's check we're being sensible - each poly path should only be
+                        // sourceable from one step, and these steps should only have poly
+                        // paths that we understand
+                        for (const { sources } of layerPlan.combinations) {
+                            const overlapCheck = new Map();
+                            for (const source of sources) {
+                                const { layerPlanId, stepId } = source;
+                                const step = this.stepTracker.getStepById(stepId);
+                                const paths = step.polymorphicPaths;
+                                if (paths === null) {
+                                    throw new Error(`GrafastInternalError<170ac297-e7b2-4d15-bf3b-1c0c50a0da40>: Step ${step} shouldn't be used in a combo because it's valid in all polymorphic paths`);
+                                }
+                                for (const p of paths) {
+                                    if (overlapCheck.has(p)) {
+                                        const sourceLp = this.stepTracker.layerPlans[layerPlanId];
+                                        const dup = overlapCheck.get(p);
+                                        const dupStep = this.stepTracker.getStepById(dup.stepId);
+                                        const dupLp = this.stepTracker.layerPlans[dup.layerPlanId];
+                                        throw new Error(`GrafastInternalError<f2d906fe-7f52-4234-a172-42691613f733>: Overlapping path ${p} in ${layerPlan} found; sourced from both ${step} in ${sourceLp} and ${dupStep} in ${dupLp}`);
+                                    }
+                                    if (!newPolyPaths.has(p)) {
+                                        throw new Error(`GrafastInternalError<c697df8f-e194-42f0-9f73-c510bc2e9b74>: path ${p} in ${layerPlan} not expected; sourced from ${step}`);
+                                    }
+                                    overlapCheck.set(p, source);
+                                }
+                            }
+                        }
+                    }
+                    break;
+                }
+                case "polymorphic":
+                case "polymorphicPartition": {
+                    polyPaths = reason.polymorphicPaths;
+                    break;
+                }
+                default: {
+                    const never = reason;
+                    throw new Error(`GrafastInternalError<032aef95-97d8-4900-95f7-edc34a5d3703>: unexpected layer plan reason ${(0, inspect_js_1.inspect)(never)}`);
+                }
+            }
+            for (const step of layerPlan.steps) {
+                if (step.polymorphicPaths !== null &&
+                    step.polymorphicPaths.size !== polyPaths.size) {
+                    step._isSelectiveStep = true;
+                }
+            }
+            polyPathsByLayerPlan.set(layerPlan, polyPaths);
+            return polyPaths;
+        };
+        for (const layerPlan of this.stepTracker.layerPlans) {
+            if (!layerPlan)
+                continue;
+            processPolymorphicPathsInLayerPlan(layerPlan);
+        }
         for (const layerPlan of this.stepTracker.layerPlans) {
             if (!layerPlan) {
                 continue;
@@ -2284,7 +3247,25 @@ class OperationPlan {
             const sideEffectSteps = layerPlan.pendingSteps.filter((s) => s.hasSideEffects);
             const pending = new Set(layerPlan.pendingSteps);
             const processed = new Set();
-            let latestSideEffectStep = null;
+            const latestSideEffectStepByPolymorphicPath = new Map();
+            const getLatestSideEffectStepFor = (step) => {
+                const polymorphicPaths = [...(step.polymorphicPaths ?? [""])];
+                const latestSideEffectStep = latestSideEffectStepByPolymorphicPath.get(polymorphicPaths[0]);
+                for (let i = 1, l = polymorphicPaths.length; i < l; i++) {
+                    const se = latestSideEffectStepByPolymorphicPath.get(polymorphicPaths[i]);
+                    if (se !== latestSideEffectStep) {
+                        throw new Error(`You shouldn't have side effects in polymorphic positions; ${step} exists in ${polymorphicPaths} but these positions have mixed side effects (${latestSideEffectStep} @ ${polymorphicPaths[0]}, ${se} @ ${polymorphicPaths[i]})`);
+                    }
+                }
+                return latestSideEffectStep;
+            };
+            const setLatestSideEffectStep = (step) => {
+                const polymorphicPaths = [...(step.polymorphicPaths ?? [""])];
+                // Store this side effect for use from now on
+                for (let i = 0, l = polymorphicPaths.length; i < l; i++) {
+                    latestSideEffectStepByPolymorphicPath.set(polymorphicPaths[i], step);
+                }
+            };
             const processSideEffectPlan = (step) => {
                 if (processed.has(step) || isPrepopulatedStep(step)) {
                     return;
@@ -2317,12 +3298,13 @@ class OperationPlan {
                 for (const dep of rest) {
                     processSideEffectPlan(dep);
                 }
-                if (latestSideEffectStep !== null &&
+                const latestSideEffectStep = getLatestSideEffectStepFor(step);
+                if (latestSideEffectStep !== undefined &&
                     !(0, utils_js_1.stepADependsOnStepB)(sstep, latestSideEffectStep)) {
                     sstep.implicitSideEffectStep = latestSideEffectStep;
                 }
                 if (step.hasSideEffects) {
-                    latestSideEffectStep = step;
+                    setLatestSideEffectStep(step);
                 }
                 const phase = /*#__INLINE__*/ newLayerPlanPhase();
                 phase.checkTimeout = true;
@@ -2359,11 +3341,14 @@ class OperationPlan {
                     processed.add(step);
                     pending.delete(step);
                     const sstep = (0, utils_js_1.sudo)(step);
-                    if (latestSideEffectStep !== null &&
+                    const latestSideEffectStep = getLatestSideEffectStepFor(step);
+                    if (latestSideEffectStep !== undefined &&
                         !(0, utils_js_1.stepADependsOnStepB)(sstep, latestSideEffectStep)) {
                         sstep.implicitSideEffectStep = latestSideEffectStep;
                     }
-                    if (step.isSyncAndSafe && (0, step_js_1.isUnbatchedStep)(step)) {
+                    if (step.isSyncAndSafe &&
+                        (0, step_js_1.isUnbatchedStep)(step) &&
+                        isSafeForUnbatched(step)) {
                         if (phase.unbatchedSyncAndSafeSteps !== undefined) {
                             phase.unbatchedSyncAndSafeSteps.push({
                                 step,
@@ -2398,7 +3383,8 @@ class OperationPlan {
                                 processed.add(step);
                                 pending.delete(step);
                                 const sstep = (0, utils_js_1.sudo)(step);
-                                if (latestSideEffectStep !== null &&
+                                const latestSideEffectStep = getLatestSideEffectStepFor(step);
+                                if (latestSideEffectStep !== undefined &&
                                     !(0, utils_js_1.stepADependsOnStepB)(sstep, latestSideEffectStep)) {
                                     sstep.implicitSideEffectStep = latestSideEffectStep;
                                 }
@@ -2464,7 +3450,15 @@ class OperationPlan {
                 // don't need to actually scale it up/down.
                 //
                 // If parentSideEffectStep exists then parentLayerPlan must exist.
-                ensurePlanAvailableInLayer($sideEffect, layerPlan.parentLayerPlan);
+                if (layerPlan.reason.type === "root") {
+                    // No action
+                }
+                else if (layerPlan.reason.type === "combined") {
+                    throw new Error(`GrafastInternalError<26f6b639-637b-4db5-980b-294697317e35>: combined layer plan ${layerPlan} is not permitted to reference side effects`);
+                }
+                else {
+                    ensurePlanAvailableInLayer($sideEffect, layerPlan.reason.parentLayerPlan);
+                }
             }
             // Copy polymorphic parentStepId
             if (layerPlan.reason.type === "polymorphic") {
@@ -2474,17 +3468,31 @@ class OperationPlan {
             // Ensure list is accessible in parent layerPlan
             if (layerPlan.reason.type === "listItem") {
                 const parentStep = layerPlan.reason.parentStep;
-                ensurePlanAvailableInLayer(parentStep, layerPlan.parentLayerPlan);
+                ensurePlanAvailableInLayer(parentStep, layerPlan.reason.parentLayerPlan);
                 const stream = layerPlan.reason.stream;
                 if (stream != null) {
                     if (stream.initialCountStepId) {
-                        ensurePlanAvailableInLayer(this.stepTracker.getStepById(stream.initialCountStepId), layerPlan.parentLayerPlan);
+                        ensurePlanAvailableInLayer(this.stepTracker.getStepById(stream.initialCountStepId), layerPlan.reason.parentLayerPlan);
                     }
                     if (stream.ifStepId) {
-                        ensurePlanAvailableInLayer(this.stepTracker.getStepById(stream.ifStepId), layerPlan.parentLayerPlan);
+                        ensurePlanAvailableInLayer(this.stepTracker.getStepById(stream.ifStepId), layerPlan.reason.parentLayerPlan);
                     }
                     if (stream.labelStepId) {
-                        ensurePlanAvailableInLayer(this.stepTracker.getStepById(stream.labelStepId), layerPlan.parentLayerPlan);
+                        ensurePlanAvailableInLayer(this.stepTracker.getStepById(stream.labelStepId), layerPlan.reason.parentLayerPlan);
+                    }
+                }
+            }
+            if (layerPlan.reason.type === "combined") {
+                // Loop through combinations and ensure source step is available in parent layer plan
+                for (const combo of layerPlan.combinations) {
+                    for (const source of combo.sources) {
+                        const { stepId, layerPlanId } = source;
+                        const sourceLayerPlan = layerPlan.reason.parentLayerPlans.find((p) => p.id === layerPlanId);
+                        if (!sourceLayerPlan) {
+                            throw new Error(`GrafastInternalError<86d15f1e-7ec8-4095-869a-548daa2cea0e>: Could not find the parent layer plan ${layerPlanId} of ${layerPlan}`);
+                        }
+                        const step = this.stepTracker.getStepById(stepId);
+                        ensurePlanAvailableInLayer(step, sourceLayerPlan);
                     }
                 }
             }
@@ -2540,6 +3548,7 @@ class OperationPlan {
                 dependencyIds: sstep.dependencies.map((d) => d.id),
                 dependencyForbiddenFlags: sstep.dependencyForbiddenFlags.slice(),
                 dependencyOnReject: sstep.dependencyOnReject.map((or) => or ? String(or) : or),
+                dependencyDataOnly: sstep.dependencyDataOnly.slice(),
                 polymorphicPaths: step.polymorphicPaths
                     ? [...step.polymorphicPaths]
                     : undefined,
@@ -2558,7 +3567,8 @@ class OperationPlan {
                 unbatchedStepIds: phase.unbatchedSyncAndSafeSteps?.map((s) => s.step.id),
             };
         }
-        function printBucketReason(reason) {
+        function printBucketReason(layerPlan) {
+            const { reason } = layerPlan;
             switch (reason.type) {
                 case "root": {
                     const { type } = reason;
@@ -2588,15 +3598,37 @@ class OperationPlan {
                     const { type, typeNames, parentStep, polymorphicPaths } = reason;
                     return {
                         type,
-                        typeNames,
+                        typeNames: [...typeNames],
                         parentStepId: parentStep.id,
                         polymorphicPaths: [...polymorphicPaths],
                     };
                 }
+                case "polymorphicPartition": {
+                    const { type, typeNames, polymorphicPaths } = reason;
+                    return {
+                        type,
+                        typeNames: [...typeNames],
+                        polymorphicPaths: [...polymorphicPaths],
+                    };
+                }
                 case "subroutine": {
                     const { type, parentStep } = reason;
                     return { type, parentStepId: parentStep.id };
                 }
+                case "combined": {
+                    const { type, parentLayerPlans } = reason;
+                    return {
+                        type,
+                        parentLayerPlanIds: [...parentLayerPlans].map((l) => l.id),
+                        combinations: layerPlan.combinations.map((c) => ({
+                            sources: c.sources.map((f) => ({
+                                layerPlanId: f.layerPlanId,
+                                stepId: f.stepId,
+                            })),
+                            targetStepId: c.targetStepId,
+                        })),
+                    };
+                }
                 default: {
                     const never = reason;
                     throw new Error(`Failed to process layer plan reason ${(0, inspect_js_1.inspect)(never)}`);
@@ -2604,21 +3636,22 @@ class OperationPlan {
             }
         }
         function printBucket(lp) {
-            lp.reason;
             return {
                 id: lp.id,
-                reason: printBucketReason(lp.reason),
+                reason: printBucketReason(lp),
                 parentSideEffectStepId: lp.parentSideEffectStep?.id ?? null,
                 copyStepIds: lp.copyStepIds,
                 phases: lp.phases.map(printPhase),
                 steps: lp.steps.map(printStep),
-                children: lp.children.map(printBucket),
+                childIds: lp.children.map((c) => c.id),
                 rootStepId: lp.rootStep ? lp.rootStep.id : null,
             };
         }
         return {
             version: "v1",
-            rootBucket: printBucket(this.rootLayerPlan),
+            buckets: this.stepTracker.layerPlans
+                .filter((b) => b != null)
+                .map(printBucket),
         };
     }
     finishSubroutine(subroutineStep, layerPlan) {
@@ -2672,16 +3705,25 @@ class OperationPlan {
      * 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)();
+        let cache = this._cacheStepStoreByActionKeyByLayerPlan.get(layerPlan.id);
+        if (!cache) {
+            cache = Object.create(null);
+            this._cacheStepStoreByActionKeyByLayerPlan.set(layerPlan.id, cache);
+        }
+        return this._cacheStep(cache, ownerStep, actionKey, cacheKey, cb);
+    }
+    /** @internal */
+    cacheImmutableStep(actionKey, cacheKey /* Anything suitable to be the key in a Map */, cb) {
+        const cache = this._immutableCacheStepStoreAndActionKey;
+        return this._cacheStep(cache, this.variableValuesStep, actionKey, cacheKey, cb);
+    }
+    _cacheStep(store, ownerStep, actionKey, cacheKey /* Anything suitable to be the key in a Map */, cb) {
         const paths = (0, withGlobalLayerPlan_js_1.currentPolymorphicPaths)();
-        const cache = (this._cacheStepStoreByLayerPlanAndActionKey[`${actionKey}|${layerPlan.id}|${ownerStep.id}`] ??= new Map());
+        const cache = (store[`${actionKey}|${ownerStep.id}|${paths == null ? "" : [...paths].join(",")}`] ??= new Map());
         const cacheIt = () => {
             const stepToCache = cb();
             if (!(stepToCache instanceof index_js_1.Step)) {
@@ -2696,14 +3738,6 @@ class OperationPlan {
         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 {
@@ -2715,10 +3749,10 @@ class OperationPlan {
      * from setting hasSideEffects on an ExecutableStep, among other places.
      */
     resetCache() {
-        this._cacheStepStoreByLayerPlanAndActionKey = Object.create(null);
+        this._cacheStepStoreByActionKeyByLayerPlan.clear();
     }
     withRootLayerPlan(cb) {
-        return (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(this.rootLayerPlan, exports.POLYMORPHIC_ROOT_PATHS, cb);
+        return (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(this.rootLayerPlan, exports.POLYMORPHIC_ROOT_PATHS, null, cb);
     }
 }
 exports.OperationPlan = OperationPlan;
@@ -2832,4 +3866,96 @@ function throwNoNewStepsError(operationPlan, actionDescription, step, previousSt
         .map((s) => String(s))
         .join(", ")}`);
 }
+function isSafeForUnbatched(step) {
+    // Never run (potential) stream steps as unbatched, otherwise they won't be
+    // able to stream!
+    if (step._stepOptions.stream)
+        return false;
+    // Non-unary steps are safe for unbatched execution
+    if (step._isUnary === false)
+        return true;
+    // Unary steps are only safe for unbatched execution _if_ their polymorphic
+    // paths match that of their bucket.
+    // !! search "f4ce2c83"
+    if (step.polymorphicPaths === null)
+        return true;
+    // PERF: this can probably be optimized further
+    return false;
+}
+function defaultPlanType($stepOrSpecifier, info) {
+    const $__typename = $stepOrSpecifier.toTypename?.() ??
+        (info.resolverEmulation
+            ? (0, graphqlResolver_js_1.graphqlResolveType)($stepOrSpecifier, info)
+            : (0, index_js_1.get)($stepOrSpecifier, "__typename"));
+    return { $__typename };
+}
+function polymorphicPathsForLayer(layer) {
+    switch (layer.reason.type) {
+        case "polymorphic":
+        case "polymorphicPartition": {
+            return layer.reason.polymorphicPaths;
+        }
+        case "combined": {
+            const set = new Set();
+            for (const lp of layer.reason.parentLayerPlans) {
+                for (const p of polymorphicPathsForLayer(lp)) {
+                    set.add(p);
+                }
+            }
+            return set;
+        }
+        case "root": {
+            return null;
+        }
+        default: {
+            return polymorphicPathsForLayer(layer.reason.parentLayerPlan);
+        }
+    }
+}
+function stepIsValidInPolyPath($step, polyPath) {
+    if (!$step.polymorphicPaths)
+        return true;
+    let trimmed = polyPath;
+    do {
+        if ($step.polymorphicPaths.has(trimmed))
+            return true;
+        const i = trimmed.lastIndexOf(">");
+        trimmed = trimmed.slice(0, i);
+    } while (trimmed.length > 0 && trimmed[0] === ">");
+    return false;
+}
+function isPeerLayerPlan(lp1, lp2) {
+    if (lp1 == null || lp2 == null) {
+        return false;
+    }
+    if (lp1 === lp2)
+        return true;
+    if (lp1.reason.type === "polymorphicPartition" &&
+        lp2.reason.type === "polymorphicPartition" &&
+        lp1.reason.parentLayerPlan === lp2.reason.parentLayerPlan) {
+        return true;
+    }
+    return false;
+}
+/**
+ * NOTE: includes `start` itself, so it's not _truly_ descendents
+ */
+function getDescendents(start, childrenByLayerPlan) {
+    const descendents = new Set();
+    const queue = [start];
+    while (queue.length > 0) {
+        const current = queue.pop();
+        // Already seen
+        if (descendents.has(current))
+            continue;
+        descendents.add(current);
+        const children = childrenByLayerPlan.get(current);
+        if (children) {
+            for (const child of children) {
+                queue.push(child);
+            }
+        }
+    }
+    return descendents;
+}
 //# sourceMappingURL=OperationPlan.js.map