grafast 0.1.1-beta.21 → 0.1.1-beta.22

package/dist/step.js

@@ -7,20 +7,21 @@ exports.assertStep = assertStep;
 exports.isUnbatchedStep = isUnbatchedStep;
 exports.isObjectLikeStep = isObjectLikeStep;
 exports.isListLikeStep = isListLikeStep;
-exports.isPolymorphicStep = isPolymorphicStep;
 exports.isListCapableStep = isListCapableStep;
 exports.assertListCapableStep = assertListCapableStep;
+exports.stepHasToSpecifier = stepHasToSpecifier;
+exports.stepHasToRecord = stepHasToRecord;
 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 constants_js_1 = require("./constants.js");
 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");
 const utils_js_1 = require("./utils.js");
 /**
  * This indicates that a step never executes (e.g. __ItemStep and __ValueStep)
@@ -41,7 +42,7 @@ function throwDestroyed() {
     throw new Error(message);
 }
 function isDeepDepSkippable($dep) {
-    return interfaces_js_1.$$deepDepSkip in $dep && typeof $dep[interfaces_js_1.$$deepDepSkip] === "function";
+    return constants_js_1.$$deepDepSkip in $dep && typeof $dep[constants_js_1.$$deepDepSkip] === "function";
 }
 function reallyAssertFinalized(plan) {
     if (!plan.isFinalized) {
@@ -55,7 +56,7 @@ exports.assertFinalized = !dev_js_1.isDev ? dev_js_1.noop : reallyAssertFinalize
  * they must be able to execute to return values.
  */
 class Step {
-    static { _a = interfaces_js_1.$$subroutine, _b = lock_js_1.$$unlock; }
+    static { _a = constants_js_1.$$subroutine, _b = lock_js_1.$$unlock; }
     constructor() {
         this[_a] = null;
         /**
@@ -70,7 +71,9 @@ class Step {
         /**
          * (default = ALL_FLAGS & ~FLAG_NULL)
          */
-        this.defaultForbiddenFlags = interfaces_js_1.DEFAULT_FORBIDDEN_FLAGS;
+        this.defaultForbiddenFlags = constants_js_1.DEFAULT_FORBIDDEN_FLAGS;
+        /** @internal */
+        this._refs = [];
         /**
          * 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
@@ -83,6 +86,7 @@ class Step {
          * @experimental
          */
         this.peerKey = null;
+        this.__trappableFlags = constants_js_1.TRAPPABLE_FLAGS;
         this.isArgumentsFinalized = false;
         this.isFinalized = false;
         this.debug = (0, global_js_1.getDebug)();
@@ -91,6 +95,8 @@ class Step {
         this.operationPlan = layerPlan.operationPlan;
         this._isUnary = true;
         this._isUnaryLocked = false;
+        // Populated in `OperationPlan` during `finalizeLayerPlans`
+        this._isSelectiveStep = false;
         this.implicitSideEffectStep = null;
         this.hasSideEffects ??= false;
         let hasSideEffects = false;
@@ -146,6 +152,7 @@ class Step {
         this.dependencies = [];
         this.dependencyForbiddenFlags = [];
         this.dependencyOnReject = [];
+        this.dependencyDataOnly = [];
         this.dependents = [];
         this.isOptimized = false;
         this.allowMultipleOptimizations = false;
@@ -165,21 +172,39 @@ class Step {
         return this._isUnary;
     }
     withMyLayerPlan(callback) {
-        return (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(this.layerPlan, this.polymorphicPaths, callback);
+        return (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(this.layerPlan, this.polymorphicPaths, null, callback);
     }
     /** @experimental */
     withLayerPlan(callback) {
-        return (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(this.layerPlan, this.polymorphicPaths, callback);
+        return (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(this.layerPlan, this.polymorphicPaths, null, callback);
     }
     getStep(id) {
         return this.layerPlan.getStep(id, this);
     }
     getDepOptions(depId) {
+        this._assertAccessAllowed(depId);
+        return this._getDepOptions(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 };
+        const dataOnly = this.dependencyDataOnly[depId];
+        const acceptFlags = constants_js_1.ALL_FLAGS & ~forbiddenFlags;
+        return { step, acceptFlags, onReject, dataOnly };
+    }
+    /**
+     * @internal
+     */
+    _assertAccessAllowed(depId) {
+        const phase = this.operationPlan.phase;
+        if (phase !== "optimize" && phase !== "plan")
+            return;
+        const step = this.dependencies[depId];
+        const dataOnly = this.dependencyDataOnly[depId];
+        if (dataOnly) {
+            throw new Error(`Dependency ${depId} (${step}) of ${this} was declared as "data only", so retrieval is forbidden.`);
+        }
     }
     getDep(_depId, _throwOnFlagged = false) {
         // This gets replaced when `__FlagStep` is loaded. Were we on ESM we could
@@ -212,7 +237,7 @@ class Step {
         // __ItemStep and __ListTransformStep are safe to walk through, but other
         // classes may not be.
         while (isDeepDepSkippable($dep)) {
-            $dep = $dep[interfaces_js_1.$$deepDepSkip]();
+            $dep = $dep[constants_js_1.$$deepDepSkip]();
         }
         return $dep;
     }
@@ -246,18 +271,109 @@ class Step {
     planJSONExtra() {
         return undefined;
     }
+    /**
+     * **IF IN DOUBT, USE `.addDependency()` INSTEAD!
+     *
+     * This **DANGEROUS** method allows you to create a reference to another
+     * step. A reference is like a dependency except it has no runtime impact -
+     * the data is not passed into execute. In general you should only add
+     * references to steps that you directly or indirectly depend on (e.g. an
+     * ancestor step) so that you may communicate with said step during
+     * `optimize` (for example). Sometimes it's acceptable to reference steps
+     * that you don't transitively depend on; in those cases you're permitted to
+     * pass an `allowIndirectReason` to explain to yourself and others why you
+     * are breaking these rules.
+     *
+     * @experimental
+     */
+    addRef(rawStep, allowIndirectReason = null) {
+        const step = this.operationPlan.stepTracker.getStepById(rawStep.id);
+        if (dev_js_1.isDev && !allowIndirectReason && !(0, utils_js_1.stepADependsOnStepB)(this, step)) {
+            const allRefs = (step, allDepIds = new Set()) => {
+                allDepIds.add(step.id);
+                for (const dep of step.dependencies) {
+                    allRefs(dep, allDepIds);
+                }
+                return allDepIds;
+            };
+            const refs1 = allRefs(this);
+            const refs2 = allRefs(step);
+            // const commonRefs = refs1.union(refs2);
+            const commonRefs = new Set([...refs1].filter((v) => refs2.has(v)));
+            const printDeps = (step, depth) => {
+                const isCommon = commonRefs.has(step.id);
+                const stepDesc = isCommon
+                    ? chalk_1.default.bgWhite.black `<${step}>`
+                    : String(step);
+                return `${"  ".repeat(depth)}${stepDesc}${!isCommon && step.dependencies.length > 0 ? `:\n${step.dependencies.map((d) => printDeps(d, depth + 1)).join("\n")}` : ""}`;
+            };
+            throw new Error(`${this} has created a reference to ${step} which is not depended on (directly or indirectly)
+Self:
+${printDeps(this, 1)}
+Reference:
+${printDeps(step, 1)}
+  `);
+        }
+        else if (!(0, utils_js_1.stepAMayDependOnStepB)(this, step)) {
+            throw new Error(`${this}.addRef(${step}) forbidden: invalid plan heirarchy`);
+        }
+        return this._refs.push(step.id) - 1;
+    }
+    /**
+     * Allows you to dereference a reference made via `addRef`. Will resolve to
+     * whatever that step is now (or null if not found). Note that referenced
+     * referenced steps may change to a new step instance due to lifecycle
+     * methods (e.g. deduplicate) or even to an entirely separate class
+     * altogether (e.g. due to optimize). References are not guaranteed to be
+     * honoured.
+     *
+     * @experimental
+     */
+    getRef(refIdx) {
+        if (!["plan", "validate", "optimize"].includes(this.operationPlan.phase)) {
+            throw new Error(`Cannot call ${this}.getRef() when the operation plan phase is ${this.operationPlan.phase}; getRef may only be called during planning.`);
+        }
+        if (refIdx == null)
+            return null;
+        return (this.operationPlan.stepTracker.getStepById(this._refs[refIdx]) ?? null);
+    }
     canAddDependency(step) {
         return (0, utils_js_1.stepAMayDependOnStepB)(this, step);
     }
-    addDependency(stepOrOptions) {
-        const options = stepOrOptions instanceof Step
-            ? { step: stepOrOptions, skipDeduplication: false }
-            : stepOrOptions;
+    _addDependency(options) {
         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)`);
+            throw new Error(`Cannot add dependency ${options.step} to ${this} since the former is in a deeper layerPlan (${options.step.layerPlan} deeper than ${this.layerPlan}; creates a catch-22)`);
         }
         return this.operationPlan.stepTracker.addStepDependency(this, options);
     }
+    addDependency(stepOrOptions) {
+        const options = {
+            dataOnly: false,
+            skipDeduplication: false,
+            ...(stepOrOptions instanceof Step
+                ? { step: stepOrOptions }
+                : stepOrOptions),
+        };
+        return this._addDependency(options);
+    }
+    addDataDependency(stepOrOptions) {
+        const opts = stepOrOptions instanceof Step ? { step: stepOrOptions } : stepOrOptions;
+        return this._addDependency({
+            dataOnly: true,
+            skipDeduplication: false,
+            ...opts,
+        });
+    }
+    // Currently identical to addDependency
+    addStrongDependency(stepOrOptions) {
+        return this._addDependency({
+            dataOnly: false,
+            skipDeduplication: false,
+            ...(stepOrOptions instanceof Step
+                ? { step: stepOrOptions }
+                : stepOrOptions),
+        });
+    }
     /**
      * Adds "unary" dependencies; in `execute({count, values})` you'll receive a
      * `values[index]` (where `index` is the return value of this function) with
@@ -267,7 +383,7 @@ class Step {
     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)`);
+            throw new Error(`Cannot add a unary dependency on ${options.step} to ${this} since the former is in a deeper layerPlan (creates a catch-22)`);
         }
         return this.operationPlan.stepTracker.addStepUnaryDependency(this, options);
     }
@@ -323,7 +439,7 @@ class Step {
      */
     /* abstract */
     execute(details) {
-        // ESLint/TS: ignore not used.
+        // eslint-disable-next-line @typescript-eslint/no-unused-expressions
         details;
         throw new Error(`${this} has not implemented an 'execute' method`);
     }
@@ -419,7 +535,6 @@ class UnbatchedStep extends Step {
         super.finalize();
     }
     execute({ indexMap, values, extra, }) {
-        console.warn(`${this} didn't call 'super.finalize()' in the finalize method.`);
         const depCount = this.dependencies.length;
         return indexMap((i) => {
             try {
@@ -454,10 +569,6 @@ function isObjectLikeStep(plan) {
 function isListLikeStep(plan) {
     return "at" in plan && typeof plan.at === "function";
 }
-function isPolymorphicStep(s) {
-    return ("planForType" in s &&
-        typeof s.planForType === "function");
-}
 function isListCapableStep(plan) {
     return "listItem" in plan && typeof plan.listItem === "function";
 }
@@ -466,6 +577,12 @@ function assertListCapableStep(plan, pathDescription) {
         throw new Error(`The plan returned from '${pathDescription}' should be a list capable plan, but ${plan} does not implement the 'listItem' method.`);
     }
 }
+function stepHasToSpecifier($step) {
+    return typeof $step.toSpecifier === "function";
+}
+function stepHasToRecord($step) {
+    return typeof $step.toRecord === "function";
+}
 /** @deprecated Use isStep instead */
 exports.isExecutableStep = isStep;
 /** @deprecated Use isStep instead */

package/dist/steps/__flag.d.ts

@@ -1,5 +1,5 @@
+import { $$deepDepSkip } from "../constants.js";
 import type { DataFromStep, ExecutionDetails, ExecutionEntryFlags, GrafastResultsList } from "../interfaces.js";
-import { $$deepDepSkip } from "../interfaces.js";
 import type { ListCapableStep } from "../step.js";
 import { Step } from "../step.js";
 import type { __ItemStep } from "./__item.js";
@@ -14,6 +14,7 @@ export type ResolvedTrapValue = false | null | undefined | readonly never[];
 export interface FlagStepOptions {
     acceptFlags?: ExecutionEntryFlags;
     onReject?: Error | null;
+    dataOnly?: boolean;
     if?: Step<boolean>;
     valueForInhibited?: TrapValue;
     valueForError?: TrapValue;
@@ -47,7 +48,7 @@ export declare class __FlagStep<TStep extends Step> extends Step<DataFromStep<TS
  */
 export declare function inhibitOnNull<TStep extends Step>($step: TStep, options?: {
     if?: FlagStepOptions["if"];
-}): __FlagStep<TStep>;
+}): Step<TStep extends Step<infer U> ? Exclude<U, null | undefined> : any>;
 /**
  * Example use case: expecting a node ID that represents a User, but get one
  * that represents a Post instead: throw error to tell user they've sent invalid

package/dist/steps/__flag.js

@@ -4,24 +4,24 @@ exports.__FlagStep = exports.TRAP_ERROR_OR_INHIBITED = exports.TRAP_INHIBITED =
 exports.inhibitOnNull = inhibitOnNull;
 exports.assertNotNull = assertNotNull;
 exports.trap = trap;
+const constants_js_1 = require("../constants.js");
 const error_js_1 = require("../error.js");
 const inspect_js_1 = require("../inspect.js");
-const interfaces_js_1 = require("../interfaces.js");
 const step_js_1 = require("../step.js");
 // PUBLIC FLAGS
-exports.TRAP_ERROR = interfaces_js_1.FLAG_ERROR;
-exports.TRAP_INHIBITED = interfaces_js_1.FLAG_INHIBITED;
-exports.TRAP_ERROR_OR_INHIBITED = (interfaces_js_1.FLAG_ERROR |
-    interfaces_js_1.FLAG_INHIBITED);
+exports.TRAP_ERROR = constants_js_1.FLAG_ERROR;
+exports.TRAP_INHIBITED = constants_js_1.FLAG_INHIBITED;
+exports.TRAP_ERROR_OR_INHIBITED = (constants_js_1.FLAG_ERROR |
+    constants_js_1.FLAG_INHIBITED);
 function digestAcceptFlags(acceptFlags) {
     const parts = [];
-    if ((acceptFlags & interfaces_js_1.FLAG_NULL) === 0) {
+    if ((acceptFlags & constants_js_1.FLAG_NULL) === 0) {
         parts.push("rejectNull");
     }
-    if ((acceptFlags & interfaces_js_1.FLAG_ERROR) !== 0) {
+    if ((acceptFlags & constants_js_1.FLAG_ERROR) !== 0) {
         parts.push("trapError");
     }
-    if ((acceptFlags & interfaces_js_1.FLAG_INHIBITED) !== 0) {
+    if ((acceptFlags & constants_js_1.FLAG_INHIBITED) !== 0) {
         parts.push("trapInhibited");
     }
     return parts.join("&");
@@ -64,8 +64,8 @@ class __FlagStep extends step_js_1.Step {
         super();
         this.isSyncAndSafe = false;
         this.ifDep = null;
-        const { acceptFlags = interfaces_js_1.DEFAULT_ACCEPT_FLAGS, onReject, if: $cond, valueForInhibited = "PASS_THROUGH", valueForError = "PASS_THROUGH", } = options;
-        this.forbiddenFlags = interfaces_js_1.ALL_FLAGS & ~acceptFlags;
+        const { acceptFlags = constants_js_1.DEFAULT_ACCEPT_FLAGS, onReject, dataOnly, if: $cond, valueForInhibited = "PASS_THROUGH", valueForError = "PASS_THROUGH", } = options;
+        this.forbiddenFlags = constants_js_1.ALL_FLAGS & ~acceptFlags;
         this.onRejectReturnValue =
             onReject == null ? error_js_1.$$inhibit : (0, error_js_1.flagError)(onReject, step.id);
         this.valueForInhibited = resolveTrapValue(valueForInhibited);
@@ -77,29 +77,29 @@ class __FlagStep extends step_js_1.Step {
                 // Can't PASS_THROUGH errors since they need to be converted into TRAPPED
                 // error.
                 // TODO: should we be handling this in Grafast core?
-                (acceptFlags & interfaces_js_1.FLAG_ERROR) === 0;
+                (acceptFlags & constants_js_1.FLAG_ERROR) === 0;
         if (!this.canBeInlined) {
-            this.addDependency({ step, acceptFlags: interfaces_js_1.TRAPPABLE_FLAGS });
+            this.addDependency({ step, acceptFlags: constants_js_1.TRAPPABLE_FLAGS });
             if ($cond) {
                 this.ifDep = this.addDependency($cond);
             }
         }
         else {
-            this.addDependency({ step, acceptFlags, onReject });
+            this.addDependency({ step, acceptFlags, onReject, dataOnly });
         }
         if ((0, step_js_1.isListCapableStep)(step)) {
             this.listItem = this._listItem;
         }
     }
     toStringMeta() {
-        const acceptFlags = interfaces_js_1.ALL_FLAGS & ~this.forbiddenFlags;
+        const acceptFlags = constants_js_1.ALL_FLAGS & ~this.forbiddenFlags;
         const rej = this.onRejectReturnValue
             ? trim(String(this.onRejectReturnValue))
             : (0, inspect_js_1.inspect)(this.onRejectReturnValue);
         const $if = this.ifDep !== null ? this.getDepOptions(this.ifDep).step : null;
         return `${this.dependencies[0].id}, ${$if ? `if(${$if.id}), ` : ``}${digestAcceptFlags(acceptFlags)}, onReject: ${rej}`;
     }
-    [interfaces_js_1.$$deepDepSkip]() {
+    [constants_js_1.$$deepDepSkip]() {
         return this.getDepOptions(0).step;
     }
     // Copied over listItem if the dependent step is a list capable step
@@ -115,7 +115,8 @@ class __FlagStep extends step_js_1.Step {
         const step = this.dependencies[0];
         const forbiddenFlags = this.dependencyForbiddenFlags[0];
         const onReject = this.dependencyOnReject[0];
-        const acceptFlags = interfaces_js_1.ALL_FLAGS & ~forbiddenFlags;
+        const dataOnly = this.dependencyDataOnly[0];
+        const acceptFlags = constants_js_1.ALL_FLAGS & ~forbiddenFlags;
         if (
         // TODO: this logic could be improved so that more flag checks were
         // inlined, e.g. `trap(inhibitOnNull($foo), TRAP_INHIBIT)` should just
@@ -129,10 +130,10 @@ class __FlagStep extends step_js_1.Step {
         options.onReject === undefined ||
             options.onReject === onReject) {
             if (options.acceptFlags === undefined ||
-                options.acceptFlags === interfaces_js_1.DEFAULT_ACCEPT_FLAGS ||
+                options.acceptFlags === constants_js_1.DEFAULT_ACCEPT_FLAGS ||
                 options.acceptFlags === acceptFlags ||
                 false) {
-                return { step, acceptFlags, onReject };
+                return { step, acceptFlags, onReject, dataOnly };
             }
         }
         return null;
@@ -173,16 +174,16 @@ class __FlagStep extends step_js_1.Step {
             const cond = condEv ? condEv.at(i) : true;
             const forbiddenFlags = cond
                 ? thisForbiddenFlags
-                : interfaces_js_1.DEFAULT_FORBIDDEN_FLAGS;
+                : constants_js_1.DEFAULT_FORBIDDEN_FLAGS;
             // Search for "f2b3b1b3" for similar block
             const flags = dataEv._flagsAt(i);
             const disallowedFlags = flags & forbiddenFlags;
             if (disallowedFlags) {
-                if (disallowedFlags & interfaces_js_1.FLAG_INHIBITED) {
+                if (disallowedFlags & constants_js_1.FLAG_INHIBITED) {
                     // We were already rejected, maintain this
                     return error_js_1.$$inhibit;
                 }
-                else if (disallowedFlags & interfaces_js_1.FLAG_ERROR) {
+                else if (disallowedFlags & constants_js_1.FLAG_ERROR) {
                     // We were already rejected, maintain this
                     return (0, error_js_1.flagError)(dataEv.at(i));
                 }
@@ -192,10 +193,10 @@ class __FlagStep extends step_js_1.Step {
                 }
             }
             else {
-                if (flags & interfaces_js_1.FLAG_ERROR && this.valueForError !== false) {
+                if (flags & constants_js_1.FLAG_ERROR && this.valueForError !== false) {
                     return valueForError;
                 }
-                if (flags & interfaces_js_1.FLAG_INHIBITED && this.valueForInhibited !== false) {
+                if (flags & constants_js_1.FLAG_INHIBITED && this.valueForInhibited !== false) {
                     return valueForInhibited;
                 }
                 // Assume pass-through
@@ -223,7 +224,7 @@ exports.__FlagStep = __FlagStep;
 function inhibitOnNull($step, options) {
     return new __FlagStep($step, {
         ...options,
-        acceptFlags: interfaces_js_1.DEFAULT_ACCEPT_FLAGS & ~interfaces_js_1.FLAG_NULL,
+        acceptFlags: constants_js_1.DEFAULT_ACCEPT_FLAGS & ~constants_js_1.FLAG_NULL,
     });
 }
 /**
@@ -234,20 +235,21 @@ function inhibitOnNull($step, options) {
 function assertNotNull($step, message, options) {
     return new __FlagStep($step, {
         ...options,
-        acceptFlags: interfaces_js_1.DEFAULT_ACCEPT_FLAGS & ~interfaces_js_1.FLAG_NULL,
+        acceptFlags: constants_js_1.DEFAULT_ACCEPT_FLAGS & ~constants_js_1.FLAG_NULL,
         onReject: new error_js_1.SafeError(message),
     });
 }
 function trap($step, acceptFlags, options) {
     return new __FlagStep($step, {
         ...options,
-        acceptFlags: (acceptFlags & interfaces_js_1.TRAPPABLE_FLAGS) | interfaces_js_1.FLAG_NULL,
+        acceptFlags: (acceptFlags & constants_js_1.TRAPPABLE_FLAGS) | constants_js_1.FLAG_NULL,
     });
 }
 // Have to overwrite the getDep method due to circular dependency
 step_js_1.Step.prototype.getDep = function (depId, throwOnFlagged = false) {
-    const { step, acceptFlags, onReject } = this.getDepOptions(depId);
-    if (acceptFlags === interfaces_js_1.DEFAULT_ACCEPT_FLAGS && onReject == null) {
+    this._assertAccessAllowed(depId);
+    const { step, acceptFlags, onReject, dataOnly } = this.getDepOptions(depId);
+    if (acceptFlags === constants_js_1.DEFAULT_ACCEPT_FLAGS && onReject == null) {
         return step;
     }
     else {
@@ -255,7 +257,7 @@ step_js_1.Step.prototype.getDep = function (depId, throwOnFlagged = false) {
             throw new Error(`When retrieving dependency ${step} of ${this}, the dependency is flagged as ${digestAcceptFlags(acceptFlags)}/onReject=${String(onReject)}. Please use \`this.getDepOptions(depId)\` instead, and handle the flags`);
         }
         // Return a __FlagStep around options.step so that all the options are preserved.
-        return new __FlagStep(step, { acceptFlags, onReject });
+        return new __FlagStep(step, { acceptFlags, onReject, dataOnly });
     }
 };
 //# sourceMappingURL=__flag.js.map

package/dist/steps/__inputObject.d.ts

@@ -14,7 +14,7 @@ export declare class __InputObjectStep<TInputType extends GraphQLInputObjectType
     isSyncAndSafe: boolean;
     private inputFields;
     constructor(inputObjectType: TInputType, inputValues: NotVariableValueNode | undefined);
-    optimize(): import("./constant.js").ConstantStep<null> | this;
+    optimize(): this | import("./constant.js").ConstantStep<null>;
     finalize(): void;
     unbatchedExecute(_extra: UnbatchedExecutionExtra, ...values: any[]): any;
     get(attrName: string): AnyInputStep;

package/dist/steps/__inputStaticLeaf.d.ts

@@ -6,14 +6,15 @@ import { UnbatchedStep } from "../step.js";
  * @see __InputDynamicScalarStep
  */
 export declare class __InputStaticLeafStep<TLeaf = any> extends UnbatchedStep<TLeaf> {
+    private readonly coercedValue;
     static $$export: {
         moduleName: string;
         exportName: string;
     };
     isSyncAndSafe: boolean;
-    private readonly coercedValue;
-    constructor(inputType: GraphQLLeafType, value: IntValueNode | FloatValueNode | StringValueNode | BooleanValueNode | NullValueNode | EnumValueNode | undefined);
+    constructor(coercedValue: any);
     unbatchedExecute(): TLeaf;
     optimize(): import("./constant.js").ConstantStep<any>;
 }
+export declare function __inputStaticLeaf(inputType: GraphQLLeafType, value: IntValueNode | FloatValueNode | StringValueNode | BooleanValueNode | NullValueNode | EnumValueNode | undefined): __InputStaticLeafStep<any>;
 //# sourceMappingURL=__inputStaticLeaf.d.ts.map

package/dist/steps/__inputStaticLeaf.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.__InputStaticLeafStep = void 0;
+exports.__inputStaticLeaf = __inputStaticLeaf;
 const tslib_1 = require("tslib");
 const graphql = tslib_1.__importStar(require("graphql"));
+const global_js_1 = require("../global.js");
 const step_js_1 = require("../step.js");
 const constant_js_1 = require("./constant.js");
 const { valueFromAST } = graphql;
@@ -16,15 +18,10 @@ class __InputStaticLeafStep extends step_js_1.UnbatchedStep {
         moduleName: "grafast",
         exportName: "__InputStaticLeafStep",
     }; }
-    constructor(inputType, value) {
+    constructor(coercedValue) {
         super();
+        this.coercedValue = coercedValue;
         this.isSyncAndSafe = true;
-        // `coerceInputValue` throws on coercion failure. NOTE: it's only safe for
-        // us to call coerceInputValue because we already know this is a scalar,
-        // *not* a variable, and not an object/list therefore cannot _contain_ a
-        // variable. Otherwise we'd need to process it via
-        // operationPlan.trackedVariableValuesStep.
-        this.coercedValue = value != null ? valueFromAST(value, inputType) : value;
     }
     unbatchedExecute() {
         return this.coercedValue;
@@ -42,4 +39,13 @@ class __InputStaticLeafStep extends step_js_1.UnbatchedStep {
     }
 }
 exports.__InputStaticLeafStep = __InputStaticLeafStep;
+function __inputStaticLeaf(inputType, value) {
+    // `coerceInputValue` throws on coercion failure. NOTE: it's only safe for
+    // us to call coerceInputValue because we already know this is a scalar,
+    // *not* a variable, and not an object/list therefore cannot _contain_ a
+    // variable. Otherwise we'd need to process it via
+    // operationPlan.trackedVariableValuesStep.
+    const coercedValue = value != null ? valueFromAST(value, inputType) : value;
+    return (0, global_js_1.operationPlan)().cacheImmutableStep("__inputStaticLeaf", coercedValue, () => new __InputStaticLeafStep(coercedValue));
+}
 //# sourceMappingURL=__inputStaticLeaf.js.map

package/dist/steps/__item.d.ts

@@ -1,5 +1,5 @@
+import { $$deepDepSkip } from "../constants.js";
 import type { GrafastResultsList, JSONValue } from "../index.js";
-import { $$deepDepSkip } from "../interfaces.js";
 import type { Step } from "../step.js";
 import { $$noExec, UnbatchedStep } from "../step.js";
 /**

package/dist/steps/__item.js

@@ -4,7 +4,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.__ItemStep = void 0;
 const tslib_1 = require("tslib");
 const chalk_1 = tslib_1.__importDefault(require("chalk"));
-const interfaces_js_1 = require("../interfaces.js");
+const constants_js_1 = require("../constants.js");
 const step_js_1 = require("../step.js");
 /**
  * An __ItemStep is an internal plan (users must never construct it
@@ -36,8 +36,8 @@ class __ItemStep extends step_js_1.UnbatchedStep {
     getParentStep() {
         return this.getDep(0);
     }
-    [(_a = step_js_1.$$noExec, interfaces_js_1.$$deepDepSkip)]() {
-        return this.getDep(0);
+    [(_a = step_js_1.$$noExec, constants_js_1.$$deepDepSkip)]() {
+        return this.getDepOptions(0).step;
     }
     execute() {
         throw new Error("__ItemStep must never execute");

package/dist/steps/__trackedValue.d.ts

@@ -31,10 +31,11 @@ export declare class __TrackedValueStep<TData = any, TInputType extends GraphQLI
     };
     isSyncAndSafe: boolean;
     /**
-     * Could be anything. In the case of context it could even have exotic
-     * entries such as `pgClient`.
+     * The value that was seen during planning, for us to use during eval (and
+     * add constraints on). DO NOT USE IN USER CODE because it will not
+     * necessarily reflect the values that should be used at runtime.
      */
-    private readonly value;
+    private readonly _initialValue;
     /**
      * The path that we are through the original value (the one that
      * `constraints` relates to).
@@ -50,10 +51,12 @@ export declare class __TrackedValueStep<TData = any, TInputType extends GraphQLI
      * Get the named property of an object.
      */
     get<TAttribute extends keyof TData & string>(attrName: TAttribute): __TrackedValueStepWithDollars<TData[TAttribute], TInputType extends GraphQLInputObjectType ? ReturnType<TInputType["getFields"]>[TAttribute]["type"] : undefined>;
+    private _get;
     /**
      * Get the entry at the given index in an array.
      */
     at<TIndex extends keyof TData & number>(index: TIndex): __TrackedValueStepWithDollars<TData[TIndex], TInputType extends GraphQLList<infer U> ? U & GraphQLInputType : TInputType extends GraphQLNonNull<GraphQLList<infer U>> ? U & GraphQLInputType : undefined>;
+    private _at;
     optimize(): import("../step.js").Step<any> | import("./__flag.js").__FlagStep<import("../step.js").Step<any>>;
 }
 export type __TrackedValueStepWithDollars<TData = any, TInputType extends GraphQLInputType | undefined = undefined> = __TrackedValueStep<TData, TInputType> & (TInputType extends GraphQLInputObjectType ? {