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

package/dist/step.js

@@ -1,19 +1,27 @@
 "use strict";
-var _a;
+var _a, _b;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertListCapableStep = exports.isListCapableStep = exports.assertModifierStep = exports.isModifierStep = exports.ModifierStep = exports.isPolymorphicStep = exports.isStreamableStep = exports.isListLikeStep = exports.isObjectLikeStep = exports.isUnbatchedExecutableStep = exports.assertExecutableStep = exports.isExecutableStep = exports.UnbatchedExecutableStep = exports.ExecutableStep = exports.BaseStep = exports.assertFinalized = exports.$$noExec = exports.$$deepDepSkip = void 0;
+exports.isExecutableStep = exports.UnbatchedExecutableStep = exports.ExecutableStep = exports.UnbatchedStep = exports.Step = exports.assertFinalized = exports.$$noExec = void 0;
+exports.isStep = isStep;
+exports.assertStep = assertStep;
+exports.isUnbatchedStep = isUnbatchedStep;
+exports.isObjectLikeStep = isObjectLikeStep;
+exports.isListLikeStep = isListLikeStep;
+exports.isPolymorphicStep = isPolymorphicStep;
+exports.isListCapableStep = isListCapableStep;
+exports.assertListCapableStep = assertListCapableStep;
+exports.assertExecutableStep = assertExecutableStep;
 const tslib_1 = require("tslib");
 const chalk_1 = tslib_1.__importDefault(require("chalk"));
 const tamedevil_1 = tslib_1.__importDefault(require("tamedevil"));
 const dev_js_1 = require("./dev.js");
 const withGlobalLayerPlan_js_1 = require("./engine/lib/withGlobalLayerPlan.js");
+const lock_js_1 = require("./engine/lock.js");
+const error_js_1 = require("./error.js");
 const global_js_1 = require("./global.js");
 const inspect_js_1 = require("./inspect.js");
 const interfaces_js_1 = require("./interfaces.js");
-/**
- * @internal
- */
-exports.$$deepDepSkip = Symbol("deepDepSkip_experimental");
+const utils_js_1 = require("./utils.js");
 /**
  * This indicates that a step never executes (e.g. __ItemStep and __ValueStep)
  * and thus when executed skips direct to reallyCompletedStep.
@@ -21,6 +29,7 @@ exports.$$deepDepSkip = Symbol("deepDepSkip_experimental");
  * @internal
  */
 exports.$$noExec = Symbol("noExec");
+const ref_flagError = tamedevil_1.default.ref(error_js_1.flagError, "flagError");
 function throwDestroyed() {
     let message;
     try {
@@ -32,7 +41,7 @@ function throwDestroyed() {
     throw new Error(message);
 }
 function isDeepDepSkippable($dep) {
-    return exports.$$deepDepSkip in $dep && typeof $dep[exports.$$deepDepSkip] === "function";
+    return interfaces_js_1.$$deepDepSkip in $dep && typeof $dep[interfaces_js_1.$$deepDepSkip] === "function";
 }
 function reallyAssertFinalized(plan) {
     if (!plan.isFinalized) {
@@ -42,80 +51,154 @@ function reallyAssertFinalized(plan) {
 // Optimise this away in production.
 exports.assertFinalized = !dev_js_1.isDev ? dev_js_1.noop : reallyAssertFinalized;
 /**
- * The base abstract plan type; you should not extend this directly - instead
- * use an ExecutableStep (for use when planning output fields) or a
- * ModifierStep (for use when planning arguments/input fields).
- *
- * @remarks
- *
- * Though it might seem that ModifierStep should be used for all inputs
- * (arguments, input objects), this is not the case. When planning an output
- * field, all inputs to it (including arguments, parent plan, context, etc)
- * should be other executable plans. The only time that ModifierStep is used is
- * when writing specific plans as part of the argument or input field
- * definitions themself; even in these cases the inputs to these plan resolvers
- * will be ExecutablePlans.
+ * Executable plans are the plans associated with leaves on the GraphQL tree,
+ * they must be able to execute to return values.
  */
-class BaseStep {
-    static { _a = interfaces_js_1.$$subroutine; }
+class Step {
+    static { _a = interfaces_js_1.$$subroutine, _b = lock_js_1.$$unlock; }
     constructor() {
         this[_a] = null;
+        /**
+         * For input values, set `true` if it comes from variables/arguments since
+         * they cannot be modified (even by mutations), set `false` otherwise.
+         *
+         * @internal
+         */
+        this._isImmutable = false;
+        /** @internal */
+        this[_b] = undefined;
+        /**
+         * (default = ALL_FLAGS & ~FLAG_NULL)
+         */
+        this.defaultForbiddenFlags = interfaces_js_1.DEFAULT_FORBIDDEN_FLAGS;
+        /**
+         * If the peerKey of two steps do not match, then they are definitely not
+         * peers. Use this to reduce the load on deduplicate by more quickly
+         * eradicating definitely-not-peers.
+         *
+         * Note: we may well change this to be a function in future, so it's advised
+         * that you don't use this unless you're working inside the graphile/crystal
+         * core codebase.
+         *
+         * @experimental
+         */
+        this.peerKey = null;
         this.isArgumentsFinalized = false;
         this.isFinalized = false;
         this.debug = (0, global_js_1.getDebug)();
-        this.hasSideEffects = false;
         const layerPlan = (0, withGlobalLayerPlan_js_1.currentLayerPlan)();
         this.layerPlan = layerPlan;
         this.operationPlan = layerPlan.operationPlan;
-    }
-    toString() {
-        const meta = this.toStringMeta();
-        return chalk_1.default.bold.blue(`${this.constructor.name.replace(/Step$/, "")}${meta != null && meta.length ? chalk_1.default.grey(`<${meta}>`) : ""}`);
-    }
-    /**
-     * This metadata will be merged into toString when referencing this plan.
-     */
-    toStringMeta() {
-        return null;
-    }
-    planJSONExtra() {
-        return undefined;
-    }
-    finalize() {
-        if (!this.isFinalized) {
-            this.isFinalized = true;
-        }
-        else {
-            throw new Error(`Step ${this} has already been finalized - do not call \`finalize()\` from user code!`);
-        }
-    }
-    destroy() { }
-}
-exports.BaseStep = BaseStep;
-/**
- * Executable plans are the plans associated with leaves on the GraphQL tree,
- * they must be able to execute to return values.
- */
-class ExecutableStep extends BaseStep {
-    constructor() {
-        super();
+        this._isUnary = true;
+        this._isUnaryLocked = false;
+        this.implicitSideEffectStep = null;
+        this.hasSideEffects ??= false;
+        let hasSideEffects = false;
+        const stepTracker = this.layerPlan.operationPlan.stepTracker;
+        Object.defineProperty(this, "hasSideEffects", {
+            get() {
+                return hasSideEffects;
+            },
+            set(value) {
+                /**
+                 * If steps were created after this step, an this step doesn't depend
+                 * on them, then it's no longer safe to change hasSideEffects.
+                 */
+                let nonDependentSteps = null;
+                const maxStepId = stepTracker.stepCount - 1;
+                if (this.id === maxStepId) {
+                    // All good - no more steps were created
+                }
+                else {
+                    // If the step created them during initialization and is dependent on
+                    // them, that's fine too.
+                    for (let id = this.id + 1; id <= maxStepId; id++) {
+                        const step = stepTracker.getStepById(id);
+                        if ((0, utils_js_1.stepADependsOnStepB)(this, step))
+                            continue;
+                        if (nonDependentSteps === null) {
+                            nonDependentSteps = [step];
+                        }
+                        else {
+                            nonDependentSteps.push(step);
+                        }
+                    }
+                }
+                if (nonDependentSteps === null) {
+                    hasSideEffects = value;
+                    if (value === true) {
+                        this.layerPlan.latestSideEffectStep = this;
+                        this.operationPlan.resetCache();
+                    }
+                    else if (value !== true && hasSideEffects === true) {
+                        throw new Error(`Cannot mark ${this} as having no side effects after having set it to have side effects.`);
+                    }
+                }
+                else {
+                    throw new Error(`Attempted to mark ${this} as having side effects, but other non-dependent steps (${nonDependentSteps
+                        .map(String)
+                        .join(", ")}) have already been created.`);
+                }
+            },
+            enumerable: true,
+            configurable: false,
+        });
         this.dependencies = [];
+        this.dependencyForbiddenFlags = [];
+        this.dependencyOnReject = [];
         this.dependents = [];
         this.isOptimized = false;
         this.allowMultipleOptimizations = false;
-        this._stepOptions = { stream: null };
+        this._stepOptions = { stream: null, walkIterable: false };
         this.store = true;
         this.polymorphicPaths = (0, withGlobalLayerPlan_js_1.currentPolymorphicPaths)();
+        // Important: MUST come after `this.layerPlan = ...`
         this.id = this.layerPlan._addStep(this);
     }
+    /**
+     * Generally you should only use this once the dependencies of a step are
+     * established, if you use it beforehand and it returns `true` then adding a
+     * non-unary dependency later will result in an error.
+     */
+    getAndFreezeIsUnary() {
+        this._isUnaryLocked = true;
+        return this._isUnary;
+    }
     withMyLayerPlan(callback) {
         return (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(this.layerPlan, this.polymorphicPaths, callback);
     }
+    /** @experimental */
+    withLayerPlan(callback) {
+        return (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(this.layerPlan, this.polymorphicPaths, callback);
+    }
     getStep(id) {
         return this.layerPlan.getStep(id, this);
     }
-    getDep(depId) {
-        return this.dependencies[depId];
+    getDepOptions(depId) {
+        const step = this.dependencies[depId];
+        const forbiddenFlags = this.dependencyForbiddenFlags[depId];
+        const onReject = this.dependencyOnReject[depId];
+        const acceptFlags = interfaces_js_1.ALL_FLAGS & ~forbiddenFlags;
+        return { step, acceptFlags, onReject };
+    }
+    getDep(_depId, _throwOnFlagged = false) {
+        // This gets replaced when `__FlagStep` is loaded. Were we on ESM we could
+        // just put the code here, but since we're not we have to avoid the
+        // circular dependency.
+        throw new Error(`Grafast failed to load correctly`);
+    }
+    maybeGetDep(depId, throwOnFlagged = false) {
+        return depId == null
+            ? null
+            : throwOnFlagged
+                ? this.getDep(depId, true)
+                : this.getDep(depId);
+    }
+    getDepOrConstant(_depId, _fallback) {
+        // This gets replaced when `constant` is loaded. Were we on ESM we could
+        // just put the code here, but since we're not we have to avoid the
+        // circular dependency.
+        throw new Error(`Grafast failed to load correctly`);
     }
     /**
      * Like getDep, except it skips over __ItemStep and similar steps to get to
@@ -129,48 +212,72 @@ class ExecutableStep extends BaseStep {
         // __ItemStep and __ListTransformStep are safe to walk through, but other
         // classes may not be.
         while (isDeepDepSkippable($dep)) {
-            $dep = $dep[exports.$$deepDepSkip]();
+            $dep = $dep[interfaces_js_1.$$deepDepSkip]();
         }
         return $dep;
     }
-    toString() {
-        const meta = this.toStringMeta();
-        return chalk_1.default.bold.blue(`${this.constructor.name.replace(/Step$/, "")}${this.layerPlan.id === 0 ? "" : chalk_1.default.grey(`{${this.layerPlan.id}}`)}${meta != null && meta.length ? chalk_1.default.grey(`<${meta}>`) : ""}[${(0, inspect_js_1.inspect)(this.id, {
-            colors: true,
-        })}]`);
+    /**
+     * Cache a generated step by a given identifier (cacheKey) such that we don't
+     * need to regenerate it on future calls, significantly reducing the load on
+     * deduplication later.
+     *
+     * @experimental
+     */
+    cacheStep(actionKey, cacheKey, cb) {
+        return this.operationPlan.cacheStep(this, actionKey, cacheKey, cb);
     }
-    addDependency(step, skipDeduplication = false) {
-        if (this.isFinalized) {
-            throw new Error("You cannot add a dependency after the step is finalized.");
+    toString() {
+        let meta;
+        try {
+            // If we log out too early, the meta function might fail.
+            meta = this.toStringMeta();
         }
-        if (!(step instanceof ExecutableStep)) {
-            throw new Error(`Error occurred when adding dependency for '${this}', value passed was not a step, it was '${(0, inspect_js_1.inspect)(step)}'`);
+        catch (e) {
+            // Ignore
         }
-        if (dev_js_1.isDev) {
-            // Check that we can actually add this as a dependency
-            if (!this.layerPlan.ancestry.includes(step.layerPlan)) {
-                throw new Error(
-                //console.error(
-                // This is not a GrafastInternalError
-                `Attempted to add '${step}' (${step.layerPlan}) as a dependency of '${this}' (${this.layerPlan}), but we cannot because that LayerPlan isn't an ancestor`);
-            }
+        return chalk_1.default.bold.blue(`${this.constructor.name.replace(/Step$/, "")}${this.layerPlan.id === 0 ? "" : chalk_1.default.grey(`{${this.layerPlan.id}}`)}${this._isUnary ? "➊" : ""}${this._stepOptions.stream != null ? "@s" : ""}${meta != null && meta.length ? chalk_1.default.grey(`<${meta}>`) : ""}[${(0, inspect_js_1.inspect)(this.id, { colors: true })}]`);
+    }
+    /**
+     * This metadata will be merged into toString when referencing this plan.
+     */
+    toStringMeta() {
+        return null;
+    }
+    planJSONExtra() {
+        return undefined;
+    }
+    canAddDependency(step) {
+        return (0, utils_js_1.stepAMayDependOnStepB)(this, step);
+    }
+    addDependency(stepOrOptions) {
+        const options = stepOrOptions instanceof Step
+            ? { step: stepOrOptions, skipDeduplication: false }
+            : stepOrOptions;
+        if (options.step.layerPlan.id > this.layerPlan.id) {
+            throw new Error(`Cannot add dependency ${options.step} to ${this} since the former is in a deeper layerPlan (creates a catch-22)`);
         }
-        // When copying dependencies between classes, we might not want to
-        // deduplicate because we might refer to the dependency by its index. As
-        // such, we should only dedupe by default but allow opting out.
-        if (!skipDeduplication) {
-            const existingIndex = this.dependencies.indexOf(step);
-            if (existingIndex >= 0) {
-                return existingIndex;
-            }
+        return this.operationPlan.stepTracker.addStepDependency(this, options);
+    }
+    /**
+     * Adds "unary" dependencies; in `execute({count, values})` you'll receive a
+     * `values[index]` (where `index` is the return value of this function) with
+     * `isBatch = false` so you can use the `values[index].value` property
+     * directly.
+     */
+    addUnaryDependency(stepOrOptions) {
+        const options = stepOrOptions instanceof Step ? { step: stepOrOptions } : stepOrOptions;
+        if (options.step.layerPlan.id > this.layerPlan.id) {
+            throw new Error(`Cannot add dependency ${options.step} to ${this} since the former is in a deeper layerPlan (creates a catch-22)`);
         }
-        return this.operationPlan.stepTracker.addStepDependency(this, step);
+        return this.operationPlan.stepTracker.addStepUnaryDependency(this, options);
     }
     finalize() {
         if (typeof this.isSyncAndSafe !== "boolean") {
             // Take a guess
-            const isAsync = this.execute.constructor.name === "AsyncFunction";
-            if (isAsync) {
+            if (!dev_js_1.isDev) {
+                this.isSyncAndSafe = false;
+            }
+            else if (this.execute.constructor.name === "AsyncFunction") {
                 this.isSyncAndSafe = false;
             }
             else {
@@ -182,17 +289,29 @@ class ExecutableStep extends BaseStep {
             this.execute.constructor.name === "AsyncFunction") {
             throw new Error(`${this} claims to be synchronous, however the execute method is asynchronous`);
         }
-        super.finalize();
+        if (!this.isFinalized) {
+            this.isFinalized = true;
+        }
+        else {
+            throw new Error(`Step ${this} has already been finalized - do not call \`finalize()\` from user code!`);
+        }
     }
     /**
-     * This function will be called with a `values` list: an array of entries for
-     * each incoming grafast object, where each entry in the array is a list of
-     * the values retrieved from executing the plans in `this.dependencies` for
-     * that grafast object.
+     * This function will be called with 'execution details', an object containing:
      *
-     * It must return a list with the same length as `values`, where each value
-     * in the list relates to the result of executing this plan for the
-     * corresponding entry in the `values` list.
+     * - `count`: the number of entries in the batch that's being executed
+     * - `values`: a tuple representing the runtime values of the steps
+     *   dependencies; each value in the tuple is an object, either a batch object
+     *   containing a list of size `count` containing the values, or a unary
+     *   object containing the single value common to all entries.
+     * - `indexMap`: helper function to map over each index from `0` to `count-1`,
+     *   returning the resulting array.
+     * - `indexForEach`: as `indexMap`, but without the array result.
+     * - `meta`: [experimental]
+     *
+     * `execute` must return a list with `count` entries, where each value in the
+     * list relates to the result of executing this plan for the corresponding
+     * entry in each of the entries in the `values` tuple.
      *
      * IMPORTANT: it is up to the execute function to cache/memoize results as
      * appropriate for performance, this can be done via the `meta` object.
@@ -202,13 +321,10 @@ class ExecutableStep extends BaseStep {
      * add attributes to meta for each purpose (e.g. use `meta.cache` for
      * memoizing results) so that you can expand your usage of meta in future.
      */
-    /* abstract */ execute(count, values, 
-    // EXPERIMENTAL
-    extra) {
+    /* abstract */
+    execute(details) {
         // ESLint/TS: ignore not used.
-        count;
-        values;
-        extra;
+        details;
         throw new Error(`${this} has not implemented an 'execute' method`);
     }
     destroy() {
@@ -221,14 +337,14 @@ class ExecutableStep extends BaseStep {
         this.optimize = throwDestroyed;
         this.finalize = throwDestroyed;
         this.execute = throwDestroyed;
-        super.destroy();
     }
 }
-exports.ExecutableStep = ExecutableStep;
-function _buildOptimizedExecuteExpression(depCount, isSyncAndSafe) {
-    const depIndexes = [];
+exports.Step = Step;
+exports.ExecutableStep = Step;
+function _buildOptimizedExecuteV2Expression(depCount, isSyncAndSafe) {
+    const identifiers = [];
     for (let i = 0; i < depCount; i++) {
-        depIndexes.push(i);
+        identifiers.push(tamedevil_1.default.identifier(`value${i}`));
     }
     const tryOrNot = (inFrag) => {
         if (isSyncAndSafe) {
@@ -239,20 +355,21 @@ function _buildOptimizedExecuteExpression(depCount, isSyncAndSafe) {
     try {
   ${tamedevil_1.default.indent(inFrag)}
     } catch (e) {
-      results[i] = e instanceof Error ? e : Promise.reject(e);
+      results[i] = ${ref_flagError}(e);
     }\
 `;
         }
     };
     return (0, tamedevil_1.default) `\
-(function execute(count, values, extra) {
-  const [
-${tamedevil_1.default.join(depIndexes.map((i) => (0, tamedevil_1.default) `    ${tamedevil_1.default.identifier(`list${i}`)},\n`), "")}\
-  ] = values;
+(function execute({
+  count,
+  values: [${tamedevil_1.default.join(identifiers, ", ")}],
+  extra,
+}) {
   const results = [];
   for (let i = 0; i < count; i++) {
 ${tryOrNot((0, tamedevil_1.default) `\
-    results[i] = this.unbatchedExecute(extra, ${tamedevil_1.default.join(depIndexes.map((depIndex) => (0, tamedevil_1.default) `${tamedevil_1.default.identifier(`list${depIndex}`)}[i]`), ", ")});\
+    results[i] = this.unbatchedExecute(extra, ${tamedevil_1.default.join(identifiers.map((identifier) => (0, tamedevil_1.default) `${identifier}.at(i)`), ", ")});\
 `)}
   }
   return results;
@@ -264,11 +381,11 @@ const safeCache = [];
 tamedevil_1.default.batch(() => {
     for (let i = 0; i <= MAX_DEPENDENCIES_TO_CACHE; i++) {
         const depCount = i;
-        const unsafeExpression = _buildOptimizedExecuteExpression(depCount, false);
+        const unsafeExpression = _buildOptimizedExecuteV2Expression(depCount, false);
         tamedevil_1.default.runInBatch(unsafeExpression, (fn) => {
             unsafeCache[depCount] = fn;
         });
-        const safeExpression = _buildOptimizedExecuteExpression(depCount, true);
+        const safeExpression = _buildOptimizedExecuteV2Expression(depCount, true);
         tamedevil_1.default.runInBatch(safeExpression, (fn) => {
             safeCache[depCount] = fn;
         });
@@ -282,115 +399,77 @@ function buildOptimizedExecute(depCount, isSyncAndSafe, callback) {
         return;
     }
     // Build it
-    const expression = _buildOptimizedExecuteExpression(depCount, isSyncAndSafe);
+    const expression = _buildOptimizedExecuteV2Expression(depCount, isSyncAndSafe);
     tamedevil_1.default.runInBatch(expression, (fn) => {
         callback(fn);
     });
 }
-class UnbatchedExecutableStep extends ExecutableStep {
+class UnbatchedStep extends Step {
     static { this.$$export = {
         moduleName: "grafast",
-        exportName: "UnbatchedExecutableStep",
+        exportName: "UnbatchedStep",
     }; }
     finalize() {
-        // If they've not replaced 'execute', use our optimized form
-        if (this.execute === UnbatchedExecutableStep.prototype.execute) {
+        if (this.execute === UnbatchedStep.prototype.execute) {
+            // If they've not replaced 'execute', use our optimized form
             buildOptimizedExecute(this.dependencies.length, this.isSyncAndSafe, (fn) => {
                 this.execute = fn;
             });
         }
         super.finalize();
     }
-    execute(count, values, extra) {
+    execute({ indexMap, values, extra, }) {
         console.warn(`${this} didn't call 'super.finalize()' in the finalize method.`);
-        const results = [];
-        for (let i = 0; i < count; i++) {
+        const depCount = this.dependencies.length;
+        return indexMap((i) => {
             try {
-                const tuple = values.map((list) => list[i]);
-                results[i] = this.unbatchedExecute(extra, ...tuple);
+                const tuple = [];
+                for (let j = 0; j < depCount; j++) {
+                    tuple[j] = values[j].at(i);
+                }
+                return this.unbatchedExecute(extra, ...tuple);
             }
             catch (e) {
-                results[i] = e instanceof Error ? e : Promise.reject(e);
+                return (0, error_js_1.flagError)(e);
             }
-        }
-        return results;
+        });
     }
 }
-exports.UnbatchedExecutableStep = UnbatchedExecutableStep;
-function isExecutableStep(step) {
-    return (step instanceof BaseStep &&
-        "execute" in step &&
-        typeof step.execute === "function");
+exports.UnbatchedStep = UnbatchedStep;
+exports.UnbatchedExecutableStep = UnbatchedStep;
+function isStep(step) {
+    return step instanceof Step;
 }
-exports.isExecutableStep = isExecutableStep;
-function assertExecutableStep(step) {
-    if (!isExecutableStep(step)) {
-        throw new Error(`Expected an executable step, but received something else: ${(0, inspect_js_1.inspect)(step)}`);
+function assertStep(step) {
+    if (!isStep(step)) {
+        throw new Error(`Expected a step, but received something else: ${(0, inspect_js_1.inspect)(step)}`);
     }
 }
-exports.assertExecutableStep = assertExecutableStep;
-function isUnbatchedExecutableStep(step) {
-    return (isExecutableStep(step) &&
-        typeof step.unbatchedExecute === "function");
+function isUnbatchedStep(step) {
+    return isStep(step) && typeof step.unbatchedExecute === "function";
 }
-exports.isUnbatchedExecutableStep = isUnbatchedExecutableStep;
 function isObjectLikeStep(plan) {
     return "get" in plan && typeof plan.get === "function";
 }
-exports.isObjectLikeStep = isObjectLikeStep;
 function isListLikeStep(plan) {
     return "at" in plan && typeof plan.at === "function";
 }
-exports.isListLikeStep = isListLikeStep;
-function isStreamableStep(plan) {
-    return typeof plan.stream === "function";
-}
-exports.isStreamableStep = isStreamableStep;
 function isPolymorphicStep(s) {
     return ("planForType" in s &&
         typeof s.planForType === "function");
 }
-exports.isPolymorphicStep = isPolymorphicStep;
-/**
- * Modifier plans modify their parent plan (which may be another ModifierStep
- * or an ExecutableStep). First they gather all the requirements from their
- * children (if any) being applied to them, then they apply themselves to their
- * parent plan. This application is done through the `apply()` method.
- *
- * Modifier plans do not use dependencies.
- */
-class ModifierStep extends BaseStep {
-    constructor($parent) {
-        super();
-        this.$parent = $parent;
-        this.id = this.layerPlan._addModifierStep(this);
-    }
-    toString() {
-        const meta = this.toStringMeta();
-        return chalk_1.default.bold.blue(`${this.constructor.name.replace(/Step$/, "")}${meta != null && meta.length ? chalk_1.default.grey(`<${meta}>`) : ""}[${(0, inspect_js_1.inspect)(this.id, {
-            colors: true,
-        })}]`);
-    }
-}
-exports.ModifierStep = ModifierStep;
-function isModifierStep(plan) {
-    return "apply" in plan && typeof plan.apply === "function";
-}
-exports.isModifierStep = isModifierStep;
-function assertModifierStep(plan, pathDescription) {
-    if (!isModifierStep(plan)) {
-        throw new Error(`The plan returned from '${pathDescription}' should be a modifier plan, but it does not implement the 'apply' method.`);
-    }
-}
-exports.assertModifierStep = assertModifierStep;
 function isListCapableStep(plan) {
     return "listItem" in plan && typeof plan.listItem === "function";
 }
-exports.isListCapableStep = isListCapableStep;
 function assertListCapableStep(plan, pathDescription) {
     if (!isListCapableStep(plan)) {
         throw new Error(`The plan returned from '${pathDescription}' should be a list capable plan, but ${plan} does not implement the 'listItem' method.`);
     }
 }
-exports.assertListCapableStep = assertListCapableStep;
+/** @deprecated Use isStep instead */
+exports.isExecutableStep = isStep;
+/** @deprecated Use isStep instead */
+function assertExecutableStep(step) {
+    return assertStep(step);
+}
 //# sourceMappingURL=step.js.map