grafast 0.1.1-beta.6 → 0.1.1-beta.7

package/README.md

@@ -55,6 +55,7 @@ And please give some love to our featured sponsors 🤩:
 <td align="center"><a href="https://stellate.co/"><img src="https://graphile.org/images/sponsors/Stellate.png" width="90" height="90" alt="Stellate" /><br />Stellate</a> *</td>
 </tr><tr>
 <td align="center"><a href="https://gosteelhead.com/"><img src="https://graphile.org/images/sponsors/steelhead.svg" width="90" height="90" alt="Steelhead" /><br />Steelhead</a> *</td>
+<td align="center"><a href="https://www.sylvera.com/"><img src="https://graphile.org/images/sponsors/sylvera.svg" width="90" height="90" alt="Sylvera" /><br />Sylvera</a> *</td>
 </tr></table>
 
 <em>\* Sponsors the entire Graphile suite</em>

package/dist/dev.d.ts

@@ -1,2 +1,3 @@
+export declare const isTest: boolean;
 export declare function noop(): void;
 //# sourceMappingURL=dev.d.ts.map

package/dist/dev.js

@@ -1,17 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.noop = exports.isDev = void 0;
+exports.noop = exports.isTest = exports.isDev = void 0;
 /**
  * @internal
  */
 const graphileEnv = typeof process !== "undefined" ? process.env.GRAPHILE_ENV : undefined;
 const nodeEnv = typeof process !== "undefined" ? process.env.NODE_ENV : undefined;
+const mode = graphileEnv !== undefined ? graphileEnv : nodeEnv;
 /**
  * @internal
  */
-exports.isDev = graphileEnv !== undefined
-    ? graphileEnv === "development" || graphileEnv === "test"
-    : nodeEnv === "development" || nodeEnv === "test";
+exports.isDev = mode === "development" || mode === "test";
+exports.isTest = mode === "test";
 function noop() { }
 exports.noop = noop;
 if (typeof process !== "undefined" &&
@@ -19,7 +19,7 @@ if (typeof process !== "undefined" &&
     typeof nodeEnv === "undefined") {
     console.warn(`The GRAPHILE_ENV environmental variable is not set; Grafast will run in production mode. In your development environments, it's recommended that you set \`GRAPHILE_ENV=development\` to opt in to additional checks that will provide guidance and help you to catch issues in your code earlier, and other changes such as formatting to improve your development experience.`);
 }
-else if (exports.isDev) {
+else if (exports.isDev && !exports.isTest) {
     console.warn(`Grafast is running in development mode due to \`${graphileEnv !== undefined
         ? `GRAPHILE_ENV=${graphileEnv}`
         : `NODE_ENV=${nodeEnv}`}\`; this is recommended for development environments (and strongly discouraged in production), but will impact on performance - in particular, planning will be significantly more expensive.`);

package/dist/engine/LayerPlan.js

@@ -5,8 +5,8 @@ const tslib_1 = require("tslib");
 const lru_1 = tslib_1.__importDefault(require("@graphile/lru"));
 const tamedevil_1 = tslib_1.__importDefault(require("tamedevil"));
 const assert = tslib_1.__importStar(require("../assert.js"));
-const error_js_1 = require("../error.js");
 const inspect_js_1 = require("../inspect.js");
+const interfaces_js_1 = require("../interfaces.js");
 const polymorphic_js_1 = require("../polymorphic.js");
 const executeBucket_js_1 = require("./executeBucket.js");
 function isBranchingLayerPlan(layerPlan) {
@@ -76,8 +76,8 @@ class LayerPlan {
          */
         this.rootStep = null;
         /**
-         * Which plans the results for which are available in a parent bucket need to
-         * be "copied across" to this bucket because plans in this bucket still
+         * Which steps the results for which are available in a parent bucket need to
+         * be "copied across" to this bucket because steps in this bucket still
          * reference them?
          *
          * @internal
@@ -132,7 +132,7 @@ class LayerPlan {
         const reasonExtra = this.reason.type === "polymorphic"
             ? `{${this.reason.typeNames.join(",")}}`
             : "";
-        const deps = this.copyStepIds.length > 0 ? `%${this.copyStepIds}` : "";
+        const deps = this.copyStepIds.length > 0 ? `/${this.copyStepIds}` : "";
         return `LayerPlan<${this.id}${chain}?${this.reason.type}${reasonExtra}!${this.rootStep?.id ?? "x"}${deps}>`;
     }
     print(depth = 0) {
@@ -158,17 +158,18 @@ class LayerPlan {
         return this.operationPlan._addModifierStep(step);
     }
     finalize() {
-        if (this.reason.type === "nullableBoundary" ||
-            this.reason.type === "listItem") {
-            const n = this.copyStepIds.length;
-            const signature = this.reason.type[0] + n;
-            withNewBucketFactory(signature, n, this.reason.type, (fn) => {
+        if (
+        // this.reason.type === "nullableBoundary" ||
+        this.reason.type === "listItem") {
+            const u = this.copyStepIds.length;
+            const signature = `${this.reason.type[0]}_${u}`;
+            withNewBucketFactory(signature, u, this.reason.type, (fn) => {
                 this.newBucket = fn(this.copyStepIds);
             });
         }
     }
     newBucket(parentBucket) {
-        const copyStepIds = this.copyStepIds;
+        const { copyStepIds } = this;
         const store = new Map();
         const polymorphicPathList = this.reason.type === "mutationField"
             ? parentBucket.polymorphicPathList
@@ -178,20 +179,41 @@ class LayerPlan {
         let size = 0;
         switch (this.reason.type) {
             case "nullableBoundary": {
-                const itemStepId = this.rootStep?.id;
-                assert.ok(itemStepId != null, "GrafastInternalError<f8136364-46c7-4886-b2ae-51319826f97d>: nullableStepStore layer plan has no rootStepId");
-                const nullableStepStore = parentBucket.store.get(itemStepId);
-                if (!nullableStepStore) {
-                    throw new Error(`GrafastInternalError<017dc8bf-1db1-4983-a41e-e69c6652e4c7>: could not find entry '${itemStepId}' (${parentBucket.layerPlan.operationPlan.dangerouslyGetStep(itemStepId)}) in store for ${parentBucket.layerPlan}`);
+                if (this.rootStep == null) {
+                    throw new Error("GrafastInternalError<f8136364-46c7-4886-b2ae-51319826f97d>: nullableStepStore layer plan has no rootStepId");
                 }
+                const itemStepId = this.rootStep.id;
                 // PERF: if parent bucket has no nulls/errors in `itemStepId`
                 // then we can just copy everything wholesale rather than building
                 // new arrays and looping.
                 const hasNoNullsOrErrors = false;
-                if (hasNoNullsOrErrors) {
+                if (this.rootStep._isUnary) {
+                    const fieldValue = parentBucket.store.get(itemStepId);
+                    const forbiddenFlags = fieldValue._entryFlags & interfaces_js_1.FORBIDDEN_BY_NULLABLE_BOUNDARY_FLAGS;
+                    if (forbiddenFlags) {
+                        size = 0;
+                    }
+                    else {
+                        size = parentBucket.size;
+                        store.set(itemStepId, fieldValue);
+                        for (const stepId of copyStepIds) {
+                            store.set(stepId, parentBucket.store.get(stepId));
+                        }
+                        for (let i = 0; i < size; i++) {
+                            map.set(i, i);
+                            polymorphicPathList[i] = parentBucket.polymorphicPathList[i];
+                            iterators[i] = parentBucket.iterators[i];
+                        }
+                    }
+                }
+                else if (hasNoNullsOrErrors) {
+                    const nullableStepStore = parentBucket.store.get(itemStepId);
+                    if (!nullableStepStore) {
+                        throw new Error(`GrafastInternalError<017dc8bf-1db1-4983-a41e-e69c6652e4c7>: could not find entry '${itemStepId}' (${parentBucket.layerPlan.operationPlan.dangerouslyGetStep(itemStepId)}) in store for ${parentBucket.layerPlan}`);
+                    }
                     store.set(itemStepId, nullableStepStore);
-                    for (const planId of copyStepIds) {
-                        store.set(planId, parentBucket.store.get(planId));
+                    for (const stepId of copyStepIds) {
+                        store.set(stepId, parentBucket.store.get(stepId));
                     }
                     for (let originalIndex = 0; originalIndex < parentBucket.size; originalIndex++) {
                         const newIndex = size++;
@@ -203,16 +225,26 @@ class LayerPlan {
                 }
                 else {
                     const itemStepIdList = [];
-                    store.set(itemStepId, itemStepIdList);
-                    // Prepare store with an empty list for each copyPlanId
-                    for (const planId of copyStepIds) {
-                        store.set(planId, []);
+                    store.set(itemStepId, (0, executeBucket_js_1.batchExecutionValue)(itemStepIdList));
+                    for (const stepId of copyStepIds) {
+                        const ev = parentBucket.store.get(stepId);
+                        if (ev.isBatch) {
+                            // Prepare store with an empty list for each copyPlanId
+                            store.set(stepId, (0, executeBucket_js_1.batchExecutionValue)([]));
+                        }
+                        else {
+                            store.set(stepId, ev);
+                        }
+                    }
+                    const nullableStepStore = parentBucket.store.get(itemStepId);
+                    if (!nullableStepStore) {
+                        throw new Error(`GrafastInternalError<017dc8bf-1db1-4983-a41e-e69c6652e4c7>: could not find entry '${itemStepId}' (${parentBucket.layerPlan.operationPlan.dangerouslyGetStep(itemStepId)}) in store for ${parentBucket.layerPlan}`);
                     }
                     // We'll typically be creating fewer nullableBoundary bucket entries
                     // than we have parent bucket entries (because we exclude nulls), so
                     // we must "multiply up" (down) the store entries.
                     for (let originalIndex = 0; originalIndex < parentBucket.size; originalIndex++) {
-                        const fieldValue = nullableStepStore[originalIndex];
+                        const fieldValue = nullableStepStore.at(originalIndex);
                         if (fieldValue != null) {
                             const newIndex = size++;
                             map.set(originalIndex, newIndex);
@@ -220,9 +252,12 @@ class LayerPlan {
                             polymorphicPathList[newIndex] =
                                 parentBucket.polymorphicPathList[originalIndex];
                             iterators[newIndex] = parentBucket.iterators[originalIndex];
-                            for (const planId of copyStepIds) {
-                                store.get(planId)[newIndex] =
-                                    parentBucket.store.get(planId)[originalIndex];
+                            for (const stepId of copyStepIds) {
+                                const ev = store.get(stepId);
+                                if (ev.isBatch) {
+                                    const orig = parentBucket.store.get(stepId);
+                                    ev._copyResult(newIndex, orig, originalIndex);
+                                }
                             }
                         }
                     }
@@ -235,32 +270,52 @@ class LayerPlan {
                 if (!listStepStore) {
                     throw new Error(`GrafastInternalError<314865b0-f7e8-4e81-b966-56e5a0de562e>: could not find entry '${listStepId}' (${parentBucket.layerPlan.operationPlan.dangerouslyGetStep(listStepId)}) in store for layerPlan ${parentBucket.layerPlan}`);
                 }
-                const itemStepId = this.rootStep?.id;
-                if (itemStepId == null) {
+                if (this.rootStep == null) {
                     throw new Error("GrafastInternalError<b3a2bff9-15c6-47e2-aa82-19c862324f1a>: listItem layer plan has no rootStepId");
                 }
-                store.set(itemStepId, []);
-                // Prepare store with an empty list for each copyPlanId
-                for (const planId of copyStepIds) {
-                    store.set(planId, []);
+                const itemStepId = this.rootStep.id;
+                // Item steps are **NOT** unary
+                const itemStepIdList = this.rootStep._isUnary ? null : [];
+                if (this.rootStep._isUnary) {
+                    // handled later
+                    const list = listStepStore.at(0);
+                    store.set(itemStepId, (0, executeBucket_js_1.unaryExecutionValue)(Array.isArray(list) ? list[0] : list));
+                }
+                else {
+                    store.set(itemStepId, (0, executeBucket_js_1.batchExecutionValue)(itemStepIdList));
+                }
+                for (const stepId of copyStepIds) {
+                    const ev = parentBucket.store.get(stepId);
+                    if (ev.isBatch) {
+                        // Prepare store with an empty list for each copyPlanId
+                        store.set(stepId, (0, executeBucket_js_1.batchExecutionValue)([]));
+                    }
+                    else {
+                        store.set(stepId, ev);
+                    }
                 }
                 // We'll typically be creating more listItem bucket entries than we
                 // have parent buckets, so we must "multiply up" the store entries.
                 for (let originalIndex = 0; originalIndex < parentBucket.size; originalIndex++) {
-                    const list = listStepStore[originalIndex];
+                    const list = listStepStore.at(originalIndex);
                     if (Array.isArray(list)) {
                         const newIndexes = [];
                         map.set(originalIndex, newIndexes);
                         for (let j = 0, l = list.length; j < l; j++) {
                             const newIndex = size++;
                             newIndexes.push(newIndex);
-                            store.get(itemStepId)[newIndex] = list[j];
+                            if (itemStepIdList !== null) {
+                                itemStepIdList[newIndex] = list[j];
+                            }
                             polymorphicPathList[newIndex] =
                                 parentBucket.polymorphicPathList[originalIndex];
                             iterators[newIndex] = parentBucket.iterators[originalIndex];
-                            for (const planId of copyStepIds) {
-                                store.get(planId)[newIndex] =
-                                    parentBucket.store.get(planId)[originalIndex];
+                            for (const stepId of copyStepIds) {
+                                const ev = store.get(stepId);
+                                if (ev.isBatch) {
+                                    const orig = parentBucket.store.get(stepId);
+                                    ev._copyResult(newIndex, orig, originalIndex);
+                                }
                             }
                         }
                     }
@@ -273,8 +328,8 @@ class LayerPlan {
                 for (let i = 0; i < parentBucket.size; i++) {
                     map.set(i, i);
                 }
-                for (const planId of copyStepIds) {
-                    store.set(planId, parentBucket.store.get(planId));
+                for (const stepId of copyStepIds) {
+                    store.set(stepId, parentBucket.store.get(stepId));
                 }
                 break;
             }
@@ -287,20 +342,24 @@ class LayerPlan {
                 // We're only copying over the entries that match this type (note:
                 // they may end up being null, but that's okay)
                 const targetTypeNames = this.reason.typeNames;
-                for (const planId of copyStepIds) {
-                    store.set(planId, []);
-                    if (!parentBucket.store.has(planId)) {
-                        throw new Error(`GrafastInternalError<548f0d84-4556-4189-8655-fb16aa3345a6>: new bucket for ${this} wants to copy ${this.operationPlan.dangerouslyGetStep(planId)}, but bucket for ${parentBucket.layerPlan} doesn't contain that plan`);
+                for (const stepId of copyStepIds) {
+                    const ev = parentBucket.store.get(stepId);
+                    if (!ev) {
+                        throw new Error(`GrafastInternalError<548f0d84-4556-4189-8655-fb16aa3345a6>: new bucket for ${this} wants to copy ${this.operationPlan.dangerouslyGetStep(stepId)}, but bucket for ${parentBucket.layerPlan} doesn't contain that plan`);
+                    }
+                    if (ev.isBatch) {
+                        store.set(stepId, (0, executeBucket_js_1.batchExecutionValue)([]));
+                    }
+                    else {
+                        store.set(stepId, ev);
                     }
                 }
                 for (let originalIndex = 0; originalIndex < parentBucket.size; originalIndex++) {
-                    const value = polymorphicPlanStore[originalIndex];
-                    if (value == null) {
-                        continue;
-                    }
-                    if ((0, error_js_1.isGrafastError)(value)) {
+                    const flags = polymorphicPlanStore._flagsAt(originalIndex);
+                    if (flags & (interfaces_js_1.FLAG_ERROR | interfaces_js_1.FLAG_INHIBITED | interfaces_js_1.FLAG_NULL)) {
                         continue;
                     }
+                    const value = polymorphicPlanStore.at(originalIndex);
                     const typeName = (0, polymorphic_js_1.resolveType)(value);
                     if (!targetTypeNames.includes(typeName)) {
                         continue;
@@ -314,8 +373,11 @@ class LayerPlan {
                     polymorphicPathList[newIndex] = newPolymorphicPath;
                     iterators[newIndex] = parentBucket.iterators[originalIndex];
                     for (const planId of copyStepIds) {
-                        store.get(planId)[newIndex] =
-                            parentBucket.store.get(planId)[originalIndex];
+                        const ev = store.get(planId);
+                        if (ev.isBatch) {
+                            const orig = parentBucket.store.get(planId);
+                            ev._copyResult(newIndex, orig, originalIndex);
+                        }
                     }
                 }
                 break;
@@ -345,7 +407,7 @@ class LayerPlan {
                 size,
                 store,
                 // PERF: not necessarily, if we don't copy the errors, we don't have the errors.
-                hasErrors: parentBucket.hasErrors,
+                flagUnion: parentBucket.flagUnion,
                 polymorphicPathList,
                 iterators,
             }, parentBucket.metaByMetaKey);
@@ -369,8 +431,9 @@ const te_parentBucketDotPolymorphicPathList = (0, tamedevil_1.default) `parentBu
 const te_parentBucketDotIterators = (0, tamedevil_1.default) `parentBucket.iterators`;
 const te_emptyArray = (0, tamedevil_1.default) `[]`;
 const ref_newBucket = tamedevil_1.default.ref(executeBucket_js_1.newBucket, "newBucket");
+const ref_batchExecutionValue = tamedevil_1.default.ref(executeBucket_js_1.batchExecutionValue, "batchExecutionValue");
 function makeNewBucketExpression(signature, reasonType, inner) {
-    return (0, tamedevil_1.default) `\
+    const expr = (0, tamedevil_1.default) `\
 (function ${tamedevil_1.default.identifier(`newBucket_${signature}`)}(parentBucket) {
   const store = new Map();
   const polymorphicPathList = ${reasonType === "mutationField"
@@ -389,7 +452,7 @@ ${inner}
       size,
       store,
       // PERF: not necessarily, if we don't copy the errors, we don't have the errors.
-      hasErrors: parentBucket.hasErrors,
+      flagUnion: parentBucket.flagUnion,
       polymorphicPathList,
       iterators,
     }, parentBucket.metaByMetaKey);
@@ -401,9 +464,14 @@ ${inner}
     return null;
   }
 })`;
+    // te.debug(expr);
+    return expr;
 }
 function newBucketFactoryInnerExpression(signature, copyCount, reasonType) {
     if (reasonType === "nullableBoundary") {
+        if (Math.random() < 2) {
+            throw new Error("This code no longer works since we added unary steps.");
+        }
         // PERF: if parent bucket has no nulls/errors in itemStepId
         // then we can just copy everything wholesale rather than building
         // new arrays and looping.
@@ -414,12 +482,14 @@ function newBucketFactoryInnerExpression(signature, copyCount, reasonType) {
             const te_target = tamedevil_1.default.identifier(`target${i}`);
             const te_i = tamedevil_1.default.lit(i);
             blocks.push((0, tamedevil_1.default) `\
-  const ${te_source} = parentBucket.store.get(copyPlanIds[${te_i}]);
-  const ${te_target} = [];
-  store.set(copyPlanIds[${te_i}], ${te_target});
+  const ${te_source} = parentBucket.store.get(copyStepIds[${te_i}]);
+  const ${te_target} = ${te_source}.isBatch ? ${ref_batchExecutionValue}([]) : ${te_source};
+  store.set(copyStepIds[${te_i}], ${te_target});
 `);
             copyBlocks.push((0, tamedevil_1.default) `\
-      ${te_target}[newIndex] = ${te_source}[originalIndex];
+      if(${te_target}.isBatch) {
+        ${te_target}.entries[newIndex] = ${te_source}.at(originalIndex);
+      }
 `);
         }
         return makeNewBucketExpression(signature, reasonType, (0, tamedevil_1.default) `\
@@ -427,7 +497,7 @@ function newBucketFactoryInnerExpression(signature, copyCount, reasonType) {
   const nullableStepStore = parentBucket.store.get(itemStepId);
 
   const itemStepIdList = [];
-  store.set(itemStepId, itemStepIdList);
+  store.set(itemStepId, ${ref_batchExecutionValue}(itemStepIdList));
 
   // Prepare store with an empty list for each copyPlanId
 ${tamedevil_1.default.join(blocks, "")}
@@ -440,7 +510,7 @@ ${tamedevil_1.default.join(blocks, "")}
     originalIndex < parentBucket.size;
     originalIndex++
   ) {
-    const fieldValue = nullableStepStore[originalIndex];
+    const fieldValue = nullableStepStore.at(originalIndex);
     if (fieldValue != null) {
       const newIndex = size++;
       map.set(originalIndex, newIndex);
@@ -461,19 +531,22 @@ ${tamedevil_1.default.join(copyBlocks, "")}
             const te_target = tamedevil_1.default.identifier(`target${i}`);
             const te_i = tamedevil_1.default.lit(i);
             blocks.push((0, tamedevil_1.default) `\
-  const ${te_source} = parentBucket.store.get(copyPlanIds[${te_i}]);
-  const ${te_target} = [];
-  store.set(copyPlanIds[${te_i}], ${te_target});
+  const ${te_source} = parentBucket.store.get(copyStepIds[${te_i}]);
+  const ${te_target} = ${te_source}.isBatch ? ${ref_batchExecutionValue}([]) : ${te_source};
+  store.set(copyStepIds[${te_i}], ${te_target});
   `);
             copyBlocks.push((0, tamedevil_1.default) `\
-        ${te_target}[newIndex] = ${te_source}[originalIndex];
+        if (${te_target}.isBatch) {
+          ${te_target}.entries[newIndex] = ${te_source}.at(originalIndex);
+        }
         `);
         }
         return makeNewBucketExpression(signature, reasonType, (0, tamedevil_1.default) `\
-  const listStepStore = parentBucket.store.get(this.reason.parentStep.id);
+  const listStepId = this.reason.parentStep.id;
+  const listStepStore = parentBucket.store.get(listStepId);
 
   const itemStepIdList = [];
-  store.set(this.rootStep.id, itemStepIdList);
+  store.set(this.rootStep.id, ${ref_batchExecutionValue}(itemStepIdList));
 
   // Prepare store with an empty list for each copyPlanId
   ${tamedevil_1.default.join(blocks, "")}
@@ -485,7 +558,7 @@ ${tamedevil_1.default.join(copyBlocks, "")}
     originalIndex < parentBucket.size;
     originalIndex++
   ) {
-    const list = listStepStore[originalIndex];
+    const list = listStepStore.at(originalIndex);
     if (Array.isArray(list)) {
       const newIndexes = [];
       map.set(originalIndex, newIndexes);
@@ -522,7 +595,7 @@ function withNewBucketFactory(signature, copyCount, reasonType, callback) {
     makingNewBucketCallbacks.set(signature, callbacks);
     const executorExpression = newBucketFactoryInnerExpression(signature, copyCount, reasonType);
     const factoryExpression = (0, tamedevil_1.default) `\
-function ${tamedevil_1.default.identifier(`layerPlanNewBucketFactory_${signature}`)}(copyPlanIds) {
+function ${tamedevil_1.default.identifier(`layerPlanNewBucketFactory_${signature}`)}(copyStepIds) {
   return ${executorExpression};
 }`;
     tamedevil_1.default.runInBatch(factoryExpression, (factory) => {

package/dist/engine/OperationPlan.d.ts

@@ -175,6 +175,7 @@ export declare class OperationPlan {
      * know all our dependent's needs before we optimise ourself.
      */
     private optimizeSteps;
+    private inlineSteps;
     /** Finalizes each step */
     private finalizeSteps;
     private finalizeLayerPlans;

package/dist/engine/OperationPlan.js

@@ -208,6 +208,9 @@ class OperationPlan {
         });
         this.checkTimeout();
         this.lap("optimizeSteps");
+        this.inlineSteps();
+        this.checkTimeout();
+        this.lap("inlineSteps");
         this.phase = "finalize";
         this.stepTracker.finalizeSteps();
         // Get rid of steps that are no longer needed after optimising outputPlans
@@ -810,7 +813,7 @@ class OperationPlan {
             });
             const $__item = this.itemStepForListStep(parentLayerPlan, $step, listDepth);
             const $item = (0, step_js_1.isListCapableStep)($step)
-                ? (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)($__item.layerPlan, polymorphicPaths, $step.listItem, $step, $__item)
+                ? (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)($__item.layerPlan, $__item.polymorphicPaths, $step.listItem, $step, $__item)
                 : $__item;
             this.planIntoOutputPlan(listOutputPlan, $item.layerPlan, path, polymorphicPath, polymorphicPaths, selections, null, null, nullableFieldType.ofType, $item, locationDetails, listDepth + 1);
         }
@@ -862,7 +865,7 @@ class OperationPlan {
                         }
                     }
                     catch (e) {
-                        throw new Error(`The step returned by '${path.join(".")}' is not compatible with the GraphQL object type '${nullableFieldType.name}': ${e.message}`, { cause: e });
+                        throw new Error(`The step returned by '${path.join(".")}${"[]".repeat(listDepth)}' is not compatible with the GraphQL object type '${nullableFieldType.name}': ${e.message}`, { cause: e });
                     }
                 }
                 if (!selections) {
@@ -1353,7 +1356,7 @@ class OperationPlan {
         if (step.hasSideEffects) {
             return EMPTY_ARRAY;
         }
-        const { dependencies: deps, layerPlan: layerPlan, constructor: stepConstructor, } = (0, utils_js_1.sudo)(step);
+        const { dependencies: deps, dependencyForbiddenFlags: flags, dependencyOnReject: onReject, layerPlan: layerPlan, constructor: stepConstructor, } = (0, utils_js_1.sudo)(step);
         const dependencyCount = deps.length;
         if (dependencyCount === 0) {
             let allPeers = null;
@@ -1384,15 +1387,18 @@ class OperationPlan {
             }
             const minDepth = Math.max(deferBoundaryDepth, dep.layerPlan.depth);
             let allPeers = null;
-            for (const { dependencyIndex: peerDependencyIndex, step: possiblyPeer, } of dep.dependents) {
-                const { layerPlan: peerLayerPlan } = possiblyPeer;
+            for (const { dependencyIndex: peerDependencyIndex, step: rawPossiblyPeer, } of dep.dependents) {
+                const possiblyPeer = (0, utils_js_1.sudo)(rawPossiblyPeer);
+                const { layerPlan: peerLayerPlan, dependencyForbiddenFlags: peerFlags, dependencyOnReject: peerOnReject, } = possiblyPeer;
                 if (possiblyPeer !== step &&
                     peerDependencyIndex === 0 &&
                     !possiblyPeer.hasSideEffects &&
                     possiblyPeer.constructor === stepConstructor &&
                     peerLayerPlan.depth >= minDepth &&
                     (0, utils_js_1.sudo)(possiblyPeer).dependencies.length === dependencyCount &&
-                    peerLayerPlan === ancestry[peerLayerPlan.depth]) {
+                    peerLayerPlan === ancestry[peerLayerPlan.depth] &&
+                    peerFlags[0] === flags[0] &&
+                    peerOnReject[0] === onReject[0]) {
                     if (allPeers === null) {
                         allPeers = [possiblyPeer];
                     }
@@ -1428,13 +1434,17 @@ class OperationPlan {
                     // Check the final dependency - this is likely to have the fewest
                     // dependents (since it was added last it's more likely to be
                     // unique).
-                    for (const { dependencyIndex: peerDependencyIndex, step: possiblyPeer, } of dep.dependents) {
+                    for (const { dependencyIndex: peerDependencyIndex, step: rawPossiblyPeer, } of dep.dependents) {
+                        const possiblyPeer = (0, utils_js_1.sudo)(rawPossiblyPeer);
+                        const { layerPlan: peerLayerPlan, dependencyForbiddenFlags: peerFlags, dependencyOnReject: peerOnReject, dependencies: peerDependencies, } = possiblyPeer;
                         if (possiblyPeer !== step &&
                             peerDependencyIndex === dependencyIndex &&
                             !possiblyPeer.hasSideEffects &&
                             possiblyPeer.constructor === stepConstructor &&
-                            (0, utils_js_1.sudo)(possiblyPeer).dependencies.length === dependencyCount &&
-                            possiblyPeer.layerPlan === ancestry[possiblyPeer.layerPlan.depth]) {
+                            peerDependencies.length === dependencyCount &&
+                            peerLayerPlan === ancestry[peerLayerPlan.depth] &&
+                            peerFlags[0] === flags[0] &&
+                            peerOnReject[0] === onReject[0]) {
                             possiblePeers.push(possiblyPeer);
                         }
                     }
@@ -1533,6 +1543,9 @@ class OperationPlan {
                     // unsafe. Should we do so, we should remove this.
                     break;
                 }
+                else if (step instanceof index_js_1.__FlagStep) {
+                    break;
+                }
                 else {
                     return;
                 }
@@ -1570,6 +1583,9 @@ class OperationPlan {
                     // break;
                     return;
                 }
+                else if (step instanceof index_js_1.__FlagStep) {
+                    break;
+                }
                 else {
                     // Plans that rely on external state shouldn't be hoisted because
                     // their results may change after a mutation, so the mutation should
@@ -2066,6 +2082,57 @@ class OperationPlan {
             .slice(0, 10)
             .join(", ")}`);
     }
+    inlineSteps() {
+        flagLoop: for (const $flag of this.stepTracker.activeSteps) {
+            if ($flag instanceof index_js_1.__FlagStep) {
+                // We can only inline it if it's not used by an output plan or layer plan
+                {
+                    const usages = this.stepTracker.outputPlansByRootStep.get($flag);
+                    if (usages?.size) {
+                        continue;
+                    }
+                }
+                {
+                    const usages = this.stepTracker.layerPlansByRootStep.get($flag);
+                    if (usages?.size) {
+                        continue;
+                    }
+                }
+                {
+                    const usages = this.stepTracker.layerPlansByParentStep.get($flag);
+                    if (usages?.size) {
+                        continue;
+                    }
+                }
+                // We're only going to inline one if we can inline all.
+                const toInline = [];
+                for (const dependent of $flag.dependents) {
+                    const { step, dependencyIndex } = dependent;
+                    const $dependent = (0, utils_js_1.sudo)(step);
+                    const inlineDetails = $flag.inline($dependent.getDepOptions(dependencyIndex));
+                    if (inlineDetails === null) {
+                        continue flagLoop;
+                    }
+                    toInline.push({
+                        $dependent,
+                        dependencyIndex,
+                        inlineDetails,
+                        dependent,
+                    });
+                }
+                // All of them pass the check, let's inline them
+                for (const todo of toInline) {
+                    const { $dependent, dependencyIndex, inlineDetails: { onReject, acceptFlags = interfaces_js_1.DEFAULT_ACCEPT_FLAGS }, } = todo;
+                    (0, utils_js_1.writeableArray)($dependent.dependencyOnReject)[dependencyIndex] =
+                        onReject;
+                    (0, utils_js_1.writeableArray)($dependent.dependencyForbiddenFlags)[dependencyIndex] =
+                        interfaces_js_1.ALL_FLAGS & ~acceptFlags;
+                }
+                const $flagDep = (0, utils_js_1.sudo)($flag).dependencies[0];
+                this.stepTracker.replaceStep($flag, $flagDep);
+            }
+        }
+    }
     /** Finalizes each step */
     finalizeSteps() {
         const initialStepCount = this.stepTracker.stepCount;
@@ -2092,9 +2159,13 @@ class OperationPlan {
                 if (currentLayerPlan.copyStepIds.includes(dep.id)) {
                     break;
                 }
-                if (index_js_1.isDev && this.stepTracker.getStepById(dep.id) !== dep) {
+                const targetStep = this.stepTracker.getStepById(dep.id);
+                if (index_js_1.isDev && targetStep !== dep) {
                     throw new Error(`GrafastInternalError<b291b110-396a-4c9c-814a-5466af3c50e8>: Plan mismatch; are we using a replaced step? Step ID: ${dep.id}; step: ${dep}; stepById: ${this.stepTracker.getStepById(dep.id)}`);
                 }
+                if (targetStep._isUnary) {
+                    targetStep._isUnaryLocked = true;
+                }
                 currentLayerPlan.copyStepIds.push(dep.id);
                 currentLayerPlan = currentLayerPlan.parentLayerPlan;
                 if (!currentLayerPlan) {
@@ -2312,12 +2383,16 @@ class OperationPlan {
     generatePlanJSON() {
         function printStep(step) {
             const metaString = step.toStringMeta();
+            const sstep = (0, utils_js_1.sudo)(step);
             return {
                 id: step.id,
                 stepClass: step.constructor.name,
                 metaString: metaString ? (0, index_js_1.stripAnsi)(metaString) : metaString,
+                isUnary: step._isUnary,
                 bucketId: step.layerPlan.id,
-                dependencyIds: (0, utils_js_1.sudo)(step).dependencies.map((d) => d.id),
+                dependencyIds: sstep.dependencies.map((d) => d.id),
+                dependencyForbiddenFlags: sstep.dependencyForbiddenFlags.slice(),
+                dependencyOnReject: sstep.dependencyOnReject.map((or) => or ? String(or) : or),
                 polymorphicPaths: step.polymorphicPaths
                     ? [...step.polymorphicPaths]
                     : undefined,