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

package/dist/engine/OperationPlanTypes.d.ts

@@ -0,0 +1,66 @@
+import type { FieldNode, GraphQLFieldMap, GraphQLInterfaceType, GraphQLList, GraphQLObjectType, GraphQLOutputType, GraphQLUnionType, SelectionNode } from "graphql";
+import type { SelectionSetDigest } from "../graphqlCollectFields";
+import type { LocationDetails, Maybe } from "../interfaces";
+import type { Step } from "../step";
+import type { LayerPlan, LayerPlanReasonListItemStream } from "./LayerPlan";
+import type { OutputPlan } from "./OutputPlan";
+export type StreamDetails = {
+    if: Step<boolean>;
+    initialCount: Step<number>;
+    label: Step<Maybe<string>>;
+};
+export interface CommonPlanningDetails<TType extends GraphQLOutputType | GraphQLInterfaceType | GraphQLUnionType = GraphQLOutputType> {
+    outputPlan: OutputPlan;
+    path: readonly string[];
+    planningPath: string;
+    polymorphicPaths: ReadonlySet<string> | null;
+    parentStep: Step;
+    positionType: TType;
+    layerPlan: LayerPlan;
+}
+export interface PlanIntoOutputPlanDetails extends CommonPlanningDetails<GraphQLOutputType> {
+    resolverEmulation: boolean;
+    selections: readonly SelectionNode[] | undefined;
+    parentObjectType: GraphQLObjectType | null;
+    responseKey: string | null;
+    locationDetails: LocationDetails;
+    listDepth: number;
+    streamDetails: StreamDetails | null;
+}
+export interface PlanFieldReturnTypeDetails extends Omit<PlanIntoOutputPlanDetails, "listDepth"> {
+    parentObjectType: GraphQLObjectType;
+}
+export interface ProcessGroupedFieldSetDetails extends CommonPlanningDetails<GraphQLObjectType> {
+    objectTypeFields: GraphQLFieldMap<any, any>;
+    isMutation: boolean;
+    groupedFieldSet: SelectionSetDigest;
+}
+export interface PlanSelectionSetDetails extends CommonPlanningDetails<GraphQLObjectType> {
+    resolverEmulation: boolean;
+    selections: readonly SelectionNode[];
+    isMutation?: boolean;
+}
+export interface PlanListItemDetails extends CommonPlanningDetails<GraphQLList<GraphQLOutputType>> {
+    resolverEmulation: boolean;
+    selections: readonly SelectionNode[] | undefined;
+    listDepth: number;
+    stream: LayerPlanReasonListItemStream | undefined;
+    locationDetails: LocationDetails;
+}
+export interface PolymorphicResolveTypeDetails extends CommonPlanningDetails<GraphQLInterfaceType | GraphQLUnionType> {
+    resolverEmulation: boolean;
+    selections: readonly SelectionNode[];
+    allPossibleObjectTypes: readonly GraphQLObjectType<any, any>[];
+    locationDetails: LocationDetails;
+    parentObjectType: GraphQLObjectType | null;
+    responseKey: string | null;
+    isNonNull: boolean;
+    stepForType?: ReadonlyMap<GraphQLObjectType, Step | Error>;
+}
+export interface PolymorphicPlanObjectTypeDetails extends CommonPlanningDetails<GraphQLObjectType> {
+    resolverEmulation: boolean;
+    fieldNodes: readonly FieldNode[];
+    locationDetails: LocationDetails;
+    isNonNull: boolean;
+}
+//# sourceMappingURL=OperationPlanTypes.d.ts.map

package/dist/engine/OperationPlanTypes.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=OperationPlanTypes.js.map

package/dist/engine/OutputPlan.d.ts

@@ -163,6 +163,7 @@ export declare class OutputPlan<TType extends OutputPlanType = OutputPlanType> {
     rootStep: Step, type: TType, locationDetails: LocationDetails);
     print(): string;
     toString(): string;
+    expectChild(type: GraphQLObjectType | null, key: string | null): void;
     addChild(type: GraphQLObjectType | null, key: string | null, child: OutputPlanKeyValue): void;
     getLayerPlans(layerPlans?: Set<LayerPlan<import("./LayerPlan.js").LayerPlanReason>>): Set<LayerPlan>;
     makeNextStepByLayerPlan(): Record<number, any[]>;
@@ -173,4 +174,9 @@ export declare class OutputPlan<TType extends OutputPlanType = OutputPlanType> {
 }
 export declare function coerceError(error: Error, locationDetails: LocationDetails, path: ReadonlyArray<string | number>): graphql.GraphQLError;
 export declare function nonNullError(locationDetails: LocationDetails, path: readonly (string | number)[]): graphql.GraphQLError;
+/**
+ * Finds the child of `targetParent` that has a path towards `descendent` (by
+ * walking backwards from descendent to targetParent).
+ */
+export declare function getDirectLayerPlanChild(targetParent: LayerPlan, descendent: LayerPlan): LayerPlan;
 //# sourceMappingURL=OutputPlan.d.ts.map

package/dist/engine/OutputPlan.js

@@ -4,17 +4,22 @@ exports.OutputPlan = void 0;
 exports.coerceError = coerceError;
 exports.nonNullError = nonNullError;
 exports.getChildBucketAndIndex = getChildBucketAndIndex;
+exports.getDirectLayerPlanChild = getDirectLayerPlanChild;
 const tslib_1 = require("tslib");
 const lru_1 = tslib_1.__importDefault(require("@graphile/lru"));
+const debug_1 = tslib_1.__importDefault(require("debug"));
 const graphql = tslib_1.__importStar(require("graphql"));
 const tamedevil_1 = tslib_1.__importStar(require("tamedevil"));
 const assert = tslib_1.__importStar(require("../assert.js"));
+const constants_js_1 = require("../constants.js");
 const dev_js_1 = require("../dev.js");
 const index_js_1 = require("../index.js");
 const inspect_js_1 = require("../inspect.js");
-const interfaces_js_1 = require("../interfaces.js");
-const polymorphic_js_1 = require("../polymorphic.js");
 const access_js_1 = require("../steps/access.js");
+const utils_js_1 = require("../utils.js");
+const LayerPlan_js_1 = require("./LayerPlan.js");
+const debug = (0, debug_1.default)("grafast:OutputPlan");
+const debugVerbose = debug.extend("verbose");
 const { executeSync, GraphQLBoolean, GraphQLError, GraphQLFloat, GraphQLID, GraphQLInt, GraphQLString, isObjectType, Kind, OperationTypeNode, } = graphql;
 /**
  * Defines a way of taking a layerPlan and converting it into an output value.
@@ -105,7 +110,32 @@ class OutputPlan {
         }
     }
     toString() {
-        return `OutputPlan<${this.type.mode}${this.sideEffectStep ? `^${this.sideEffectStep.id}` : ""}∈${this.layerPlan.id}!${this.rootStep.id}>`;
+        let processRootString = "";
+        if (this.processRoot != null) {
+            const fnBody = this.processRoot.toString();
+            const VALUE_ARROW = "value => ";
+            if (fnBody.startsWith(VALUE_ARROW)) {
+                const sliced = fnBody.slice(VALUE_ARROW.length);
+                if (sliced.startsWith("(value") &&
+                    sliced.endsWith(")") &&
+                    sliced.replace(/[()]/g, "").length === sliced.length - 2) {
+                    processRootString = sliced.slice(6, -1);
+                }
+                else {
+                    processRootString = `:value=>${sliced}`;
+                }
+            }
+            else {
+                processRootString = `:${fnBody}`;
+            }
+        }
+        return `OutputPlan<${this.type.mode}${this.sideEffectStep ? `^${this.sideEffectStep.id}` : ""}∈${this.layerPlan.id}!${this.rootStep.id}${processRootString}>`;
+    }
+    // HACK: ensure output objects are ordered correctly
+    expectChild(type, key) {
+        if (this.type.mode === "root" || this.type.mode === "object") {
+            this.keys[key] = undefined; // placeholder
+        }
     }
     addChild(type, key, child) {
         if (this.type.mode === "root" || this.type.mode === "object") {
@@ -155,7 +185,8 @@ class OutputPlan {
                 assert.ok(type && this.type.typeNames.includes(type.name), "GrafastInternalError<566a34ac-1138-4dbf-943e-f704819431dd>: polymorphic output plan can only addChild for a matching type");
                 assert.strictEqual(key, null, "GrafastInternalError<4346ebda-a02d-4489-b767-7a6d621a73c7>: addChild for polymorphic OutputPlan should not specify a key");
                 assert.ok(child.type === "outputPlan", "GrafastInternalError<b29285da-fb07-4943-9038-708edc785041>: polymorphic OutputPlan child must be an outputPlan");
-                assert.ok(child.outputPlan.type.mode === "object", "GrafastInternalError<203469c6-4bfa-4cd1-ae82-cc5d0132ca16>: polymorphic OutputPlan child must be an object outputPlan");
+                assert.ok(child.outputPlan.type.mode === "object" ||
+                    child.outputPlan.type.mode === "null", "GrafastInternalError<203469c6-4bfa-4cd1-ae82-cc5d0132ca16>: polymorphic OutputPlan child must be an object outputPlan");
             }
             this.childByTypeName[type.name] = child.outputPlan;
         }
@@ -218,13 +249,16 @@ class OutputPlan {
         // should be safe aga.
         const $root = this.layerPlan.operationPlan.dangerouslyGetStep(this.rootStep.id);
         if ($root instanceof index_js_1.AccessStep &&
+            $root.isSyncAndSafe && // Make sure we're not using it for streaming!
             $root.fallback === undefined &&
             $root.implicitSideEffectStep === null &&
             (!this.sideEffectStep || !(0, index_js_1.stepADependsOnStepB)($root, this.sideEffectStep))) {
             const expressionDetails = $root.unbatchedExecute[access_js_1.expressionSymbol];
-            if (expressionDetails !== undefined) {
-                // @ts-ignore
-                const { step: $parent } = $root.getDepOptions(0);
+            // @ts-ignore
+            const { step: $parent, onReject, acceptFlags } = $root._getDepOptions(0);
+            if (expressionDetails !== undefined &&
+                onReject == null &&
+                acceptFlags === constants_js_1.DEFAULT_ACCEPT_FLAGS) {
                 this.layerPlan.operationPlan.stepTracker.setOutputPlanRootStep(this, $parent);
                 const [path, fallback] = expressionDetails;
                 withFastExpression(path, fallback, (fn) => {
@@ -292,14 +326,7 @@ class OutputPlan {
                     throw new Error("GrafastInternalError<48fabdc8-ce84-45ec-ac20-35a2af9098e0>: No child output plan for list bucket?");
                 }
                 const childIsNonNull = this.childIsNonNull;
-                let directLayerPlanChild = this.child.layerPlan;
-                while (directLayerPlanChild.parentLayerPlan !== this.layerPlan) {
-                    const parent = directLayerPlanChild.parentLayerPlan;
-                    if (!parent) {
-                        throw new Error(`GrafastInternalError<d43e06d8-c533-4e7b-b3e7-af399f19c83f>: Invalid heirarchy - could not find direct layerPlan child of ${this}`);
-                    }
-                    directLayerPlanChild = parent;
-                }
+                const directLayerPlanChild = getDirectLayerPlanChild(this.layerPlan, this.child.layerPlan);
                 const canStream = directLayerPlanChild.reason.type === "listItem" &&
                     !!directLayerPlanChild.reason.stream;
                 if (childIsNonNull) {
@@ -391,63 +418,57 @@ function getChildBucketAndIndex(layerPlan, outputPlan, bucket, bucketIndex, arra
         (outputPlan != null && outputPlan.type.mode === "array")) {
         throw new Error("GrafastInternalError<83d0e3cc-7eec-4185-85b4-846540288162>: arrayIndex must be supplied iff outputPlan is an array");
     }
-    if (outputPlan != null && layerPlan === bucket.layerPlan) {
-        // Same layer; straightforward
-        return [bucket, bucketIndex];
-    }
-    const reversePath = [layerPlan];
-    let current = layerPlan;
-    while (!bucket.children[current.id]) {
-        current = current.parentLayerPlan;
-        if (!current) {
-            return null;
-        }
-        reversePath.push(current);
+    const paths = (0, utils_js_1.pathsFromAncestorToTargetLayerPlan)(bucket.layerPlan, layerPlan);
+    if (paths.length === 0) {
+        return null;
     }
-    let currentBucket = bucket;
-    let currentIndex = bucketIndex;
-    for (let l = reversePath.length, i = l - 1; i >= 0; i--) {
-        const layerPlan = reversePath[i];
-        const child = currentBucket.children[layerPlan.id];
-        if (!child) {
-            return null;
-        }
-        const out = child.map.get(currentIndex);
-        if (out == null) {
-            return null;
-        }
-        /*
-         * TEST: I think this  '|| i !== l - 1' check is saying that an array can
-         * only occur at the furthest ancestor and everything since then must be
-         * non-array. Presumably in the case of nested arrays there would be an
-         * intermediary bucket, hence why this check is allowed, but that should be
-         * tested. Also, are there any confounding factors when it comes to steps
-         * themselves using arrays for object values - for example pgSelectSingle is
-         * represented by an array (tuple), but that doesn't make it a list so it should
-         * be fine. Use tests to validate this is all fine.
-         */
-        if (arrayIndex == null || i !== l - 1) {
-            if (Array.isArray(out)) {
-                throw new Error("GrafastInternalError<db189d32-bf8f-4e58-b55f-5c5ac3bb2381>: Was expecting an arrayIndex, but none was provided");
+    toNextPath: for (const path of paths) {
+        let currentBucket = bucket;
+        let currentIndex = bucketIndex;
+        for (let i = 0, l = path.length; i < l; i++) {
+            const layerPlan = path[i];
+            const child = currentBucket.children[layerPlan.id];
+            if (!child) {
+                continue toNextPath;
             }
-            currentBucket = child.bucket;
-            currentIndex = out;
-        }
-        else {
-            if (!Array.isArray(out)) {
-                throw new Error(`GrafastInternalError<8190d09f-dc75-46ec-8162-b20ad516de41>: Cannot access array index in non-array ${(0, inspect_js_1.inspect)(out)}`);
+            const out = child.map.get(currentIndex);
+            if (out == null) {
+                continue toNextPath;
             }
-            if (!(out.length > arrayIndex)) {
-                throw new Error(`GrafastInternalError<1f596c22-368b-4d0d-94df-fb3df632b064>: Attempted to retrieve array index '${arrayIndex}' which is out of bounds of array with length '${out.length}'`);
+            /*
+             * TEST: I think this  '|| i !== l - 1' check is saying that an array can
+             * only occur at the furthest ancestor and everything since then must be
+             * non-array. Presumably in the case of nested arrays there would be an
+             * intermediary bucket, hence why this check is allowed, but that should be
+             * tested. Also, are there any confounding factors when it comes to steps
+             * themselves using arrays for object values - for example pgSelectSingle is
+             * represented by an array (tuple), but that doesn't make it a list so it should
+             * be fine. Use tests to validate this is all fine.
+             */
+            if (arrayIndex == null || i !== 0) {
+                if (Array.isArray(out)) {
+                    throw new Error("GrafastInternalError<db189d32-bf8f-4e58-b55f-5c5ac3bb2381>: Was expecting an arrayIndex, but none was provided");
+                }
+                currentBucket = child.bucket;
+                currentIndex = out;
+            }
+            else {
+                if (!Array.isArray(out)) {
+                    throw new Error(`GrafastInternalError<8190d09f-dc75-46ec-8162-b20ad516de41>: Cannot access array index in non-array ${(0, inspect_js_1.inspect)(out)}`);
+                }
+                if (!(out.length > arrayIndex)) {
+                    throw new Error(`GrafastInternalError<1f596c22-368b-4d0d-94df-fb3df632b064>: Attempted to retrieve array index '${arrayIndex}' which is out of bounds of array with length '${out.length}'`);
+                }
+                currentBucket = child.bucket;
+                currentIndex = out[arrayIndex];
             }
-            currentBucket = child.bucket;
-            currentIndex = out[arrayIndex];
         }
+        if (currentIndex == null) {
+            continue toNextPath;
+        }
+        return [currentBucket, currentIndex];
     }
-    if (currentIndex == null) {
-        return null;
-    }
-    return [currentBucket, currentIndex];
+    return null;
 }
 function makeExecutor(config) {
     const { preamble = null, inner, asString, nameExtra, skipNullHandling = false, } = config;
@@ -461,13 +482,13 @@ function makeExecutor(config) {
                     throw new Error(`GrafastInternalError<da9cc5a0-23bf-4af8-a103-92f995795398>: ${(0, index_js_1.stripAnsi)(String(this.sideEffectStep))} has no entry in ${bucket}`);
                 }
                 const seFlags = ev._flagsAt(sideEffectBucketIndex);
-                if (seFlags & interfaces_js_1.FLAG_ERROR) {
+                if (seFlags & constants_js_1.FLAG_ERROR) {
                     const seVal = ev.at(sideEffectBucketIndex);
                     throw coerceError(seVal, this.locationDetails, mutablePath.slice(1));
                 }
             }
         }
-        if (bucketRootFlags & interfaces_js_1.FLAG_ERROR) {
+        if (bucketRootFlags & constants_js_1.FLAG_ERROR) {
             throw coerceError(rawBucketRootValue, this.locationDetails, mutablePath.slice(1));
         }
         const bucketRootValue = this.processRoot !== null
@@ -498,7 +519,7 @@ function executeChildPlan(that, locationDetails, childOutputPlan, isNonNull, asS
                 throw new Error(`GrafastInternalError<d18d52b5-f5bf-42df-a2dd-80e522310b8e>: ${(0, index_js_1.stripAnsi)(String($sideEffect))} has no entry in ${bucket}`);
             }
             const flags = ev._flagsAt(sideEffectBucketIndex);
-            if (flags & interfaces_js_1.FLAG_ERROR) {
+            if (flags & constants_js_1.FLAG_ERROR) {
                 const e = coerceError(ev.at(sideEffectBucketIndex), locationDetails, mutablePath.slice(1));
                 if (isNonNull) {
                     throw e;
@@ -661,23 +682,19 @@ const stringLeafExecutorString = makeExecutor({
         }
     },
 });
-// NOTE: the reference to $$concreteType here is a (temporary) optimization; it
-// should be `resolveType(bucketRootValue)` but it's not worth the function
-// call overhead. Longer term it should just be read directly from a different
-// store.
+// TODO: do we need this or can we skip it?
 function makePolymorphicExecutor(asString) {
     return makeExecutor({
         inner(bucketRootValue, root, mutablePath, bucket, bucketIndex) {
+            const typeName = bucketRootValue;
             if (dev_js_1.isDev) {
-                if (!(0, polymorphic_js_1.isPolymorphicData)(bucketRootValue)) {
-                    throw coerceError(new Error("GrafastInternalError<db7fcda5-dc39-4568-a7ce-ee8acb88806b>: Expected polymorphic data"), this.locationDetails, mutablePath.slice(1));
-                }
+                assert.ok(typeName, "GrafastInternalError<fd3f3cf0-0789-4c74-a6cd-839c808896ed>: Could not determine concreteType for object");
             }
-            const typeName = bucketRootValue[interfaces_js_1.$$concreteType];
             const childOutputPlan = this.childByTypeName[typeName];
-            if (dev_js_1.isDev) {
-                assert.ok(typeName, "GrafastInternalError<fd3f3cf0-0789-4c74-a6cd-839c808896ed>: Could not determine concreteType for object");
-                assert.ok(childOutputPlan, `GrafastInternalError<a46999ef-41ff-4a22-bae9-fa37ff6e5f7f>: Could not determine the OutputPlan to use for '${typeName}' from '${bucket.layerPlan}'`);
+            if (!childOutputPlan) {
+                // Search: InvalidConcreteTypeName
+                console.warn(`Invalid object type name for this abstract position${this.locationDetails.parentTypeName && this.locationDetails.fieldName ? ` at ${this.locationDetails.parentTypeName}.${this.locationDetails.fieldName}` : ""}; saw %o, but expected one of ${this.type.typeNames.join(", ")}`, typeName);
+                return (asString ? "null" : null);
             }
             const directChild = bucket.children[childOutputPlan.layerPlan.id];
             if (directChild !== undefined) {
@@ -686,7 +703,13 @@ function makePolymorphicExecutor(asString) {
             else {
                 const c = getChildBucketAndIndex(childOutputPlan.layerPlan, this, bucket, bucketIndex);
                 if (!c) {
-                    throw new Error("GrafastInternalError<691509d8-31fa-4cfe-a6df-dcba21bd521f>: polymorphic executor couldn't determine child bucket");
+                    // TODO: Implies that the bucket didn't run; is this a normal
+                    // situation? We should be able to detect it and handle it more
+                    // cleanly.
+                    if (dev_js_1.isDev) {
+                        debugVerbose(`GrafastInternalWarning<691509d8-31fa-4cfe-a6df-dcba21bd521f>: polymorphic executor couldn't determine child bucket. childOutputPlan=%c, childOutputPlan.layerPlan=%c, bucket=%c`, childOutputPlan, childOutputPlan.layerPlan, bucket);
+                    }
+                    return (asString ? "null" : null);
                 }
                 const [childBucket, childBucketIndex] = c;
                 return childOutputPlan[asString ? "executeString" : "execute"](root, mutablePath, childBucket, childBucketIndex);
@@ -768,7 +791,7 @@ function makeArrayExecutor(childIsNonNull, canStream, asString) {
                 }
             }
             if (canStream) {
-                const stream = bucketRootValue[interfaces_js_1.$$streamMore];
+                const stream = bucketRootValue[constants_js_1.$$streamMore];
                 if (stream !== undefined) {
                     const labelStepId = childOutputPlan.layerPlan.reason.stream?.labelStepId;
                     root.streams.push({
@@ -1044,4 +1067,37 @@ function withFastExpression(path, fallback, callback) {
         }
     });
 }
+/**
+ * Finds the child of `targetParent` that has a path towards `descendent` (by
+ * walking backwards from descendent to targetParent).
+ */
+function getDirectLayerPlanChild(targetParent, descendent) {
+    const child = _getDirectLayerPlanChild(targetParent, descendent);
+    if (child == null) {
+        throw new Error(`GrafastInternalError<d43e06d8-c533-4e7b-b3e7-af399f19c83f>: Invalid hierarchy - could not find direct layerPlan child of ${targetParent} that leads to ${descendent}`);
+    }
+    return child;
+}
+function _getDirectLayerPlanChild(targetParent, descendent) {
+    let directLayerPlanChild = descendent;
+    let parent;
+    while ((0, LayerPlan_js_1.hasParentLayerPlan)(directLayerPlanChild.reason) &&
+        (parent = directLayerPlanChild.reason.parentLayerPlan) !== targetParent) {
+        directLayerPlanChild = parent;
+    }
+    if (directLayerPlanChild.reason.type === "combined") {
+        for (const plp of directLayerPlanChild.reason.parentLayerPlans) {
+            const dlpc = _getDirectLayerPlanChild(targetParent, plp);
+            if (dlpc)
+                return dlpc;
+        }
+        return null;
+    }
+    else if (directLayerPlanChild.reason.type === "root") {
+        return null;
+    }
+    else {
+        return directLayerPlanChild;
+    }
+}
 //# sourceMappingURL=OutputPlan.js.map

package/dist/engine/StepTracker.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StepTracker = void 0;
+const constants_js_1 = require("../constants.js");
 const dev_js_1 = require("../dev.js");
 const inspect_js_1 = require("../inspect.js");
-const interfaces_js_1 = require("../interfaces.js");
 const step_js_1 = require("../step.js");
 const utils_js_1 = require("../utils.js");
 const lock_js_1 = require("./lock.js");
@@ -40,6 +40,8 @@ class StepTracker {
         /** @internal */
         this.layerPlansByParentStep = new Map();
         /** @internal */
+        this.layerPlansByDependentStep = new Map();
+        /** @internal */
         this.layerPlans = [];
         /**
          * All the OutputPlans that were created to allow a more efficient
@@ -96,6 +98,7 @@ class StepTracker {
             case "root":
             case "subscription":
             case "mutationField":
+            case "polymorphicPartition":
             case "defer": {
                 break;
             }
@@ -115,13 +118,16 @@ class StepTracker {
             }
             case "subroutine": {
                 const parent = layerPlan.reason.parentStep;
-                if (parent[interfaces_js_1.$$subroutine] !== null) {
+                if (parent[constants_js_1.$$subroutine] !== null) {
                     throw new Error(`Steps may currently only have one subroutine. If you have need for a step with multiple subroutines, please get in touch.`);
                 }
-                parent[interfaces_js_1.$$subroutine] =
+                parent[constants_js_1.$$subroutine] =
                     layerPlan;
                 break;
             }
+            case "combined": {
+                break;
+            }
             default: {
                 const never = layerPlan.reason;
                 throw new Error(`Unexpected layerPlan reason ${never.type}`);
@@ -165,10 +171,22 @@ class StepTracker {
         }
         this.layerPlans[layerPlan.id] = null;
         // Remove layerPlan from its parent
-        if (layerPlan.parentLayerPlan !== null) {
-            const idx = layerPlan.parentLayerPlan.children.indexOf(layerPlan);
+        if (layerPlan.reason.type === "root") {
+            // no action
+        }
+        else if (layerPlan.reason.type === "combined") {
+            for (const parentLayerPlan of layerPlan.reason.parentLayerPlans) {
+                const idx = parentLayerPlan.children.indexOf(layerPlan);
+                if (idx >= 0) {
+                    parentLayerPlan.children.splice(idx, 1);
+                }
+            }
+        }
+        else {
+            const parentLayerPlan = layerPlan.reason.parentLayerPlan;
+            const idx = parentLayerPlan.children.indexOf(layerPlan);
             if (idx >= 0) {
-                layerPlan.parentLayerPlan.children.splice(idx, 1);
+                parentLayerPlan.children.splice(idx, 1);
             }
         }
         // Remove references
@@ -184,6 +202,16 @@ class StepTracker {
                     .delete(layerPlan);
             }
         }
+        if (layerPlan.reason.type === "combined") {
+            for (const combo of layerPlan.combinations) {
+                for (const source of combo.sources) {
+                    const step = this.getStepById(source.stepId);
+                    this.layerPlansByDependentStep
+                        .get(step)
+                        .delete(layerPlan);
+                }
+            }
+        }
         // Remove all plans in this layer
         const handled = new Set();
         const handle = (step) => {
@@ -220,16 +248,16 @@ class StepTracker {
         const $dependent = (0, utils_js_1.sudo)(raw$dependent);
         const $dependency = (0, utils_js_1.sudo)(options.step);
         if (!this.activeSteps.has($dependent)) {
-            throw new Error(`Cannot add ${$dependency} as a dependency of ${$dependent}; the latter is deleted!`);
+            throw new Error(`Cannot add ${$dependency} as a dependency of ${$dependent}; the latter is deleted! Explanation: https://err.red/gasdd#phase=${this.operationPlan.phase}&dependency=${encodeURIComponent(String($dependency))}&dependent=${encodeURIComponent(String($dependent))}&deleted=dependent`);
         }
         if (!this.activeSteps.has($dependency)) {
-            throw new Error(`Cannot add ${$dependency} as a dependency of ${$dependent}; the former is deleted!`);
+            throw new Error(`Cannot add ${$dependency} as a dependency of ${$dependent}; the former is deleted! Explanation: https://err.red/gasdd#phase=${this.operationPlan.phase}&dependency=${encodeURIComponent(String($dependency))}&dependent=${encodeURIComponent(String($dependent))}&deleted=dependency`);
         }
         if ($dependent.isFinalized) {
             throw new Error("You cannot add a dependency after the step is finalized.");
         }
         if (!($dependency instanceof step_js_1.Step)) {
-            throw new Error(`Error occurred when adding dependency for '${$dependent}', value passed was not a step, it was '${(0, inspect_js_1.inspect)($dependency)}'`);
+            throw new Error(`Error occurred when adding dependency for '${$dependent}', value passed was not a step, it was '${(0, inspect_js_1.inspect)($dependency)}' (phase = ${this.operationPlan.phase})`);
         }
         if (dev_js_1.isDev) {
             // Check that we can actually add this as a dependency
@@ -237,19 +265,21 @@ class StepTracker {
                 throw new Error(
                 //console.error(
                 // This is not a GrafastInternalError
-                `Attempted to add '${$dependency}' (${$dependency.layerPlan}) as a dependency of '${$dependent}' (${$dependent.layerPlan}), but we cannot because that LayerPlan isn't an ancestor`);
+                `Attempted to add '${$dependency}' (${$dependency.layerPlan}) as a dependency of '${$dependent}' (${$dependent.layerPlan}), but we cannot because that LayerPlan isn't an ancestor. (phase = ${this.operationPlan.phase})`);
             }
         }
         const dependentDependencies = (0, utils_js_1.writeableArray)($dependent.dependencies);
         const dependentDependencyForbiddenFlags = (0, utils_js_1.writeableArray)($dependent.dependencyForbiddenFlags);
         const dependentDependencyOnReject = (0, utils_js_1.writeableArray)($dependent.dependencyOnReject);
-        const { skipDeduplication, acceptFlags = interfaces_js_1.ALL_FLAGS & ~$dependent.defaultForbiddenFlags, onReject, } = options;
+        const dependentDependencyDataOnly = (0, utils_js_1.writeableArray)($dependent.dependencyDataOnly);
+        const { skipDeduplication, acceptFlags = constants_js_1.ALL_FLAGS & ~$dependent.defaultForbiddenFlags, onReject, dataOnly = false, } = options;
         // 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.
         // TODO: change this to `!skipDeduplication`
         if (skipDeduplication === false) {
-            const existingIndex = dependentDependencies.indexOf($dependency);
+            const $searchForMe = options.step;
+            const existingIndex = dependentDependencies.indexOf($searchForMe);
             if (existingIndex >= 0) {
                 return existingIndex;
             }
@@ -260,13 +290,14 @@ class StepTracker {
             }
             $dependent._isUnary = false;
         }
-        const forbiddenFlags = interfaces_js_1.ALL_FLAGS & ~(acceptFlags & interfaces_js_1.TRAPPABLE_FLAGS);
+        const forbiddenFlags = constants_js_1.ALL_FLAGS & ~(acceptFlags & $dependent.__trappableFlags);
         this.stepsWithNoDependenciesByConstructor
             .get($dependent.constructor)
             ?.delete($dependent);
         const dependencyIndex = dependentDependencies.push($dependency) - 1;
         dependentDependencyForbiddenFlags[dependencyIndex] = forbiddenFlags;
         dependentDependencyOnReject[dependencyIndex] = onReject;
+        dependentDependencyDataOnly[dependencyIndex] = dataOnly;
         (0, utils_js_1.writeableArray)($dependency.dependents).push({
             step: $dependent,
             dependencyIndex,
@@ -274,13 +305,16 @@ class StepTracker {
         return dependencyIndex;
     }
     addStepUnaryDependency($dependent, options) {
+        if (options.dataOnly) {
+            throw new Error(`${$dependent} attempted to add dataOnly unary dependency; this is not permitted.`);
+        }
         const $dependency = options.step;
+        const { nonUnaryMessage = defaultNonUnaryMessage, ...rest } = options;
         if (!$dependency._isUnary) {
-            const { nonUnaryMessage = defaultNonUnaryMessage } = options;
             throw new Error(nonUnaryMessage($dependent, $dependency));
         }
         $dependency._isUnaryLocked = true;
-        return this.addStepDependency($dependent, options);
+        return this.addStepDependency($dependent, { ...rest, dataOnly: false });
     }
     setOutputPlanRootStep(outputPlan, $dependency) {
         if (!this.activeSteps.has($dependency)) {
@@ -402,6 +436,28 @@ class StepTracker {
                 layerPlans.clear();
             }
         }
+        // Update combos
+        {
+            const layerPlans = this.layerPlansByDependentStep.get($original);
+            if (layerPlans?.size) {
+                let layerPlansByReplacementDependentStep = this.layerPlansByDependentStep.get($replacement);
+                if (!layerPlansByReplacementDependentStep) {
+                    layerPlansByReplacementDependentStep = new Set();
+                    this.layerPlansByDependentStep.set($replacement, layerPlansByReplacementDependentStep);
+                }
+                for (const layerPlan of layerPlans) {
+                    for (const combo of layerPlan.combinations) {
+                        for (const source of combo.sources) {
+                            if (source.stepId === $original.id) {
+                                source.stepId = $replacement.id;
+                            }
+                        }
+                    }
+                    layerPlansByReplacementDependentStep.add(layerPlan);
+                }
+                layerPlans.clear();
+            }
+        }
         // NOTE: had to add the code ensuring all the layer plan parentStepId's
         // existed to fix polymorphism, but it feels wrong. Should we be doing
         // something different?
@@ -456,6 +512,9 @@ class StepTracker {
         const s3 = this.layerPlansByParentStep.get($step);
         if (s3 && s3.size !== 0)
             return false;
+        const s4 = this.layerPlansByDependentStep.get($step);
+        if (s4 && s4.size !== 0)
+            return false;
         return true;
     }
     /**
@@ -498,8 +557,8 @@ class StepTracker {
      * then they can also be eradicated _except_ during the 'plan' phase.
      */
     eradicate($original) {
-        if ($original[interfaces_js_1.$$subroutine] !== null) {
-            this.deleteLayerPlan($original[interfaces_js_1.$$subroutine]);
+        if ($original[constants_js_1.$$subroutine] !== null) {
+            this.deleteLayerPlan($original[constants_js_1.$$subroutine]);
         }
         this.removeStepFromItsLayerPlan($original);
         const oldAliases = this.aliasesById[$original.id];