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

package/dist/engine/LayerPlan.js

@@ -1,31 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LayerPlan = exports.isPolymorphicLayerPlan = exports.isDeferredLayerPlan = exports.isBranchingLayerPlan = void 0;
+exports.LayerPlan = void 0;
+exports.isBranchingLayerPlan = isBranchingLayerPlan;
+exports.isDeferredLayerPlan = isDeferredLayerPlan;
+exports.isPolymorphicLayerPlan = isPolymorphicLayerPlan;
 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) {
     return layerPlan.reason.type === "polymorphic";
 }
-exports.isBranchingLayerPlan = isBranchingLayerPlan;
 function isDeferredLayerPlan(layerPlan) {
     const t = layerPlan.reason.type;
-    return (t === "stream" ||
+    return ((t === "listItem" && layerPlan.reason.stream != null) ||
         t === "subscription" ||
         t === "mutationField" ||
         t === "defer");
 }
-exports.isDeferredLayerPlan = isDeferredLayerPlan;
 function isPolymorphicLayerPlan(layerPlan) {
     const t = layerPlan.reason.type;
     return t === "polymorphic";
 }
-exports.isPolymorphicLayerPlan = isPolymorphicLayerPlan;
 /**
  * A LayerPlan represents (via "reason") either the root (root), when something
  * happens at a later time (mutationField, defer), when plurality changes
@@ -65,7 +65,6 @@ class LayerPlan {
          *
          * - root: the `operationPlan.rootValue`
          * - listItem: the `__ItemStep`
-         * - stream: also the `__ItemStep`
          * - subscription: also the `__ItemStep`
          * - mutationField: the result plan of the mutation field
          * - defer: the parent layer's rootStep (defer always results in an object, unless an error occurs)
@@ -76,8 +75,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
@@ -89,6 +88,23 @@ class LayerPlan {
         this.steps = [];
         /** @internal */
         this.pendingSteps = [];
+        /**
+         * This goes along with `parentStep` in the reason, except it applies to all
+         * layer plan types and we figure it out automatically from the parent layer
+         * plan. If this step has an error at a given index, then it should be
+         * treated as if the parentStep had an error at that same index.
+         *
+         * @internal
+         */
+        this.parentSideEffectStep = null;
+        /**
+         * This tracks the latest seen side effect at the current point in planning
+         * (such that created steps take this to be their implicitSideEffectStep).
+         * This isn't used once planning is complete.
+         *
+         * @internal
+         */
+        this.latestSideEffectStep = null;
         /**
          * Describes the order in which the steps within this LayerPlan are executed.
          *
@@ -97,6 +113,13 @@ class LayerPlan {
          * @internal
          */
         this.phases = [];
+        this._hasSetRootStep = false;
+        // This layer plan is dependent on the latest side effect. Note that when
+        // we set a `rootStep` later, if the root step is dependent on this step
+        // (directly or indirectly) we will clear this property.
+        this.parentSideEffectStep = parentLayerPlan?.latestSideEffectStep ?? null;
+        // There has yet to be any side effects created in this layer.
+        this.latestSideEffectStep = null;
         this.stepsByConstructor = new Map();
         if (parentLayerPlan !== null) {
             this.depth = parentLayerPlan.depth + 1;
@@ -132,8 +155,8 @@ class LayerPlan {
         const reasonExtra = this.reason.type === "polymorphic"
             ? `{${this.reason.typeNames.join(",")}}`
             : "";
-        const deps = this.copyStepIds.length > 0 ? `%${this.copyStepIds}` : "";
-        return `LayerPlan<${this.id}${chain}?${this.reason.type}${reasonExtra}!${this.rootStep?.id ?? "x"}${deps}>`;
+        const deps = this.copyStepIds.length > 0 ? `/${this.copyStepIds}` : "";
+        return `LayerPlan<${this.id}${chain}${this.parentSideEffectStep ? `^${this.parentSideEffectStep.id}` : ""}?${this.reason.type}${reasonExtra}!${this.rootStep?.id ?? "x"}${deps}>`;
     }
     print(depth = 0) {
         const output = [`${" ".repeat(depth * 2)}${this}`];
@@ -143,7 +166,15 @@ class LayerPlan {
         return output.join("\n");
     }
     setRootStep($root) {
+        if (this._hasSetRootStep) {
+            throw new Error(`Set root step on ${this} more than once`);
+        }
+        this._hasSetRootStep = true;
         this.operationPlan.stepTracker.setLayerPlanRootStep(this, $root);
+        // NOTE: we may clear `this.parentSideEffectStep` based on the `$root` step
+        // having an explicit dependency on `this.parentSideEffectStep`; but that
+        // will be done as part of `OperationPlan::finalizeLayerPlans()` because
+        // steps aren't assigned `implicitSideEffectStep`s until that point.
     }
     /** @internal Use plan.getStep(id) instead. */
     getStep(id, requestingStep) {
@@ -153,45 +184,76 @@ class LayerPlan {
     _addStep(step) {
         return this.operationPlan._addStep(step);
     }
-    /** @internal */
-    _addModifierStep(step) {
-        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
             : [];
         const iterators = this.reason.type === "mutationField" ? parentBucket.iterators : [];
         const map = new Map();
+        const $parentSideEffect = this.parentSideEffectStep;
+        let parentSideEffectValue;
+        if ($parentSideEffect) {
+            parentSideEffectValue = parentBucket.store.get($parentSideEffect.id);
+        }
+        else {
+            parentSideEffectValue = null;
+        }
         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 {
+                        store.set(itemStepId, fieldValue);
+                        for (const stepId of copyStepIds) {
+                            store.set(stepId, parentBucket.store.get(stepId));
+                        }
+                        const parentBucketSize = parentBucket.size;
+                        for (let originalIndex = 0; originalIndex < parentBucketSize; originalIndex++) {
+                            if (parentSideEffectValue === null ||
+                                !(parentSideEffectValue._flagsAt(originalIndex) & interfaces_js_1.FLAG_ERROR)) {
+                                const newIndex = size++;
+                                map.set(originalIndex, newIndex);
+                                polymorphicPathList[newIndex] =
+                                    parentBucket.polymorphicPathList[originalIndex];
+                                iterators[newIndex] = parentBucket.iterators[originalIndex];
+                            }
+                        }
+                    }
+                }
+                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,26 +265,41 @@ 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];
-                        if (fieldValue != null) {
+                        if ((parentSideEffectValue === null ||
+                            !(parentSideEffectValue._flagsAt(originalIndex) & interfaces_js_1.FLAG_ERROR)) &&
+                            !(nullableStepStore._flagsAt(originalIndex) & interfaces_js_1.FLAG_NULL)) {
                             const newIndex = size++;
                             map.set(originalIndex, newIndex);
+                            const fieldValue = nullableStepStore.at(originalIndex);
                             itemStepIdList[newIndex] = fieldValue;
                             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 +312,51 @@ 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
+                if (this.rootStep._isUnary) {
+                    throw new Error("listItem layer plan can't have a unary root step!");
+                }
+                const ev = (0, executeBucket_js_1.batchExecutionValue)([]);
+                store.set(itemStepId, ev);
+                for (const stepId of copyStepIds) {
+                    // Deliberate shadowing
+                    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];
-                    if (Array.isArray(list)) {
+                    const list = listStepStore.at(originalIndex);
+                    if ((parentSideEffectValue === null ||
+                        !(parentSideEffectValue._flagsAt(originalIndex) & interfaces_js_1.FLAG_ERROR)) &&
+                        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];
+                            ev.entries[newIndex] = list[j];
+                            // TODO: are these the right flags?
+                            ev._flags[newIndex] = list[j] == null ? interfaces_js_1.FLAG_NULL : interfaces_js_1.NO_FLAGS;
                             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 +369,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 +383,28 @@ 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) {
+                    const flags = polymorphicPlanStore._flagsAt(originalIndex);
+                    if (flags & (interfaces_js_1.FLAG_ERROR | interfaces_js_1.FLAG_INHIBITED | interfaces_js_1.FLAG_NULL)) {
                         continue;
                     }
-                    if ((0, error_js_1.isGrafastError)(value)) {
+                    if (parentSideEffectValue !== null &&
+                        parentSideEffectValue._flagsAt(originalIndex) & interfaces_js_1.FLAG_ERROR) {
                         continue;
                     }
+                    const value = polymorphicPlanStore.at(originalIndex);
                     const typeName = (0, polymorphic_js_1.resolveType)(value);
                     if (!targetTypeNames.includes(typeName)) {
                         continue;
@@ -314,8 +418,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 +452,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 +476,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 +497,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 +509,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 +527,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 +542,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 +555,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 +576,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 +603,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 +640,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) => {