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

package/dist/engine/OutputPlan.js

@@ -1,80 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getChildBucketAndIndex = exports.nonNullError = exports.coerceError = exports.OutputPlan = void 0;
+exports.OutputPlan = void 0;
+exports.coerceError = coerceError;
+exports.nonNullError = nonNullError;
+exports.getChildBucketAndIndex = getChildBucketAndIndex;
 const tslib_1 = require("tslib");
 const lru_1 = tslib_1.__importDefault(require("@graphile/lru"));
 const graphql = tslib_1.__importStar(require("graphql"));
 const tamedevil_1 = tslib_1.__importStar(require("tamedevil"));
 const assert = tslib_1.__importStar(require("../assert.js"));
 const dev_js_1 = require("../dev.js");
-const error_js_1 = require("../error.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 { executeSync, GraphQLBoolean, GraphQLError, GraphQLFloat, GraphQLID, GraphQLInt, GraphQLString, isObjectType, Kind, OperationTypeNode, } = graphql;
-const ref_$$error = tamedevil_1.default.ref(error_js_1.$$error, "$$error");
-const ref_coerceError = tamedevil_1.default.ref(coerceError, "coerceError");
-const ref_nonNullError = tamedevil_1.default.ref(nonNullError, "nonNullError");
-const ref_stringifyString = tamedevil_1.default.ref(tamedevil_1.stringifyString, "stringifyString");
-const ref_stringifyJSON = tamedevil_1.default.ref(tamedevil_1.stringifyJSON, "stringifyJSON");
-const ref_isPolymorphicData = tamedevil_1.default.ref(polymorphic_js_1.isPolymorphicData, "isPolymorphicData");
-const ref_$$concreteType = tamedevil_1.default.ref(interfaces_js_1.$$concreteType, "$$concreteType");
-const ref_assert = tamedevil_1.default.ref(assert, "assert");
-const ref_getChildBucketAndIndex = tamedevil_1.default.ref(getChildBucketAndIndex, "getChildBucketAndIndex");
-const ref_inspect = tamedevil_1.default.ref(inspect_js_1.inspect, "inspect");
-const ref_$$streamMore = tamedevil_1.default.ref(interfaces_js_1.$$streamMore, "$$streamMore");
-const te_String = (0, tamedevil_1.default) `String`;
-const te_nullIsFineComment = (0, tamedevil_1.default) `// root/introspection, null is fine`;
-const te_nullString = (0, tamedevil_1.default) `"null"`;
-const te_null = (0, tamedevil_1.default) `null`;
-const te_childBucket = (0, tamedevil_1.default) `childBucket`;
-const te_childBucketIndex = (0, tamedevil_1.default) `childBucketIndex`;
-const te_executeString = (0, tamedevil_1.default) `executeString`;
-const te_execute = (0, tamedevil_1.default) `execute`;
-const te_polymorphic = (0, tamedevil_1.default) `polymorphic`;
-const te_letStringLbrace = (0, tamedevil_1.default) `let string = "{";`;
-const te_stringPlusEquals = (0, tamedevil_1.default) `string +=`;
-const te_stringPlusEqualsRbrace = (0, tamedevil_1.default) `  string += "}";\n`;
-const te_stringPlusEqualsRbracket = (0, tamedevil_1.default) `    string += "]";\n`;
-const te_constObjEqualsObjectCreateNull = (0, tamedevil_1.default) `const obj = Object.create(null);`;
-const te_comma = (0, tamedevil_1.default) `,`;
-const te_specDotLocationDetails = (0, tamedevil_1.default) `spec.locationDetails`;
-const te_thisDotLocationDetails = (0, tamedevil_1.default) `this.locationDetails`;
-const te_specDotOutputPlan = (0, tamedevil_1.default) `spec.outputPlan`;
-const te_bucket = (0, tamedevil_1.default) `bucket`;
-const te_bucketIndex = (0, tamedevil_1.default) `bucketIndex`;
-const te_handleDeferred = (0, tamedevil_1.default) `
-  // Everything seems okay; queue any deferred payloads
-  for (const defer of this.deferredOutputPlans) {
-    root.queue.push({
-      root,
-      path: mutablePath.slice(1),
-      bucket,
-      bucketIndex,
-      outputPlan: defer,
-      label: defer.type.deferLabel,
-    });
-  }
-`;
-const te_string = (0, tamedevil_1.default) `string`;
-const te_object = (0, tamedevil_1.default) `object`;
-const te_obj = (0, tamedevil_1.default) `obj`;
-const te_data = (0, tamedevil_1.default) `data`;
-const te_commonErrorHandler = tamedevil_1.default.ref(commonErrorHandler, "handleError");
-const te_questionDot = (0, tamedevil_1.default) `?.`;
-const te_childBucketCBIDC = (0, tamedevil_1.default) `, childBucket, childBucketIndex, directChild`;
-const te_letString = (0, tamedevil_1.default) `let string;`;
-const te_constDataEqualsEmptyArray = (0, tamedevil_1.default) `const data = [];`;
-const te_stringEqualsEmptyArrayString = (0, tamedevil_1.default) `    string = "[]";`;
-const te_stringEqualsLeftSquareBraceString = (0, tamedevil_1.default) `    string = "[";\n`;
-const te_noopComment = (0, tamedevil_1.default) `    /* noop */`;
-const te_ifIGt0StrPlusEqualComma = (0, tamedevil_1.default) `\n      if (i > 0) { string += ","; }\n`;
-const te_dataIEquals = (0, tamedevil_1.default) `data[i] =`;
-const te_childOutputPlan = (0, tamedevil_1.default) `childOutputPlan`;
-const te_underscoreNonNull = (0, tamedevil_1.default) `_nonNull`;
-const te_underscoreStream = (0, tamedevil_1.default) `_stream`;
 /**
  * Defines a way of taking a layerPlan and converting it into an output value.
  *
@@ -104,6 +45,8 @@ class OutputPlan {
         this.type = type;
         /**
          * Appended to the root step when accessed to avoid the need for AccessSteps
+         *
+         * @internal
          */
         this.processRoot = null;
         /**
@@ -128,6 +71,8 @@ class OutputPlan {
         layerPlan.operationPlan.stepTracker.addOutputPlan(this);
         this.childByTypeName =
             this.type.mode === "polymorphic" ? Object.create(null) : undefined;
+        // NOTE: this may be cleared during `this.finalize()`
+        this.sideEffectStep = layerPlan.latestSideEffectStep;
     }
     print() {
         const type = this.type;
@@ -160,7 +105,7 @@ class OutputPlan {
         }
     }
     toString() {
-        return `OutputPlan<${this.type.mode}∈${this.layerPlan.id}!${this.rootStep.id}>`;
+        return `OutputPlan<${this.type.mode}${this.sideEffectStep ? `^${this.sideEffectStep.id}` : ""}∈${this.layerPlan.id}!${this.rootStep.id}>`;
     }
     addChild(type, key, child) {
         if (this.type.mode === "root" || this.type.mode === "object") {
@@ -253,7 +198,7 @@ class OutputPlan {
     // By just reusing the same path over and over we don't need to allocate
     // more memory for more arrays; but we must be _incredibly_ careful to
     // ensure any changes to it are reversed.
-    _mutablePath, _bucket, _bucketIndex) {
+    _mutablePath, _bucket, _bucketIndex, _rawBucketRootValue, _bucketRootFlags) {
         throw new Error(`OutputPlan.execute has yet to be built!`);
     }
     // This gets replaced with a mode-specific executor
@@ -261,16 +206,25 @@ class OutputPlan {
     // By just reusing the same path over and over we don't need to allocate
     // more memory for more arrays; but we must be _incredibly_ careful to
     // ensure any changes to it are reversed.
-    _mutablePath, _bucket, _bucketIndex) {
+    _mutablePath, _bucket, _bucketIndex, _rawBucketRootValue, _bucketRootFlags) {
         throw new Error(`OutputPlan.executeString has yet to be built!`);
     }
     optimize() {
+        // This optimization works by ridding us of access steps at the very end of
+        // paths and just accessing properties directly. In rare circumstances
+        // involving untethered side effects in earlier versions this could lead to
+        // errors being skipped and data generated previous to the error being
+        // returned; but OutputPlans now check the latestSideEffectStep so this
+        // should be safe aga.
         const $root = this.layerPlan.operationPlan.dangerouslyGetStep(this.rootStep.id);
-        if ($root instanceof index_js_1.AccessStep && $root.fallback === undefined) {
+        if ($root instanceof index_js_1.AccessStep &&
+            $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 $parent = $root.getDep(0);
+                const { step: $parent } = $root.getDepOptions(0);
                 this.layerPlan.operationPlan.stepTracker.setOutputPlanRootStep(this, $parent);
                 const [path, fallback] = expressionDetails;
                 withFastExpression(path, fallback, (fn) => {
@@ -280,6 +234,19 @@ class OutputPlan {
         }
     }
     finalize() {
+        // Clear the sideEffectStep if the rootStep explicitly depends on it.
+        // NOTE: this occurs here since more dependencies could have been added to
+        // $root after `this` was created.
+        const $sideEffect = this.sideEffectStep;
+        if ($sideEffect) {
+            const $root = this.rootStep;
+            if ($root === $sideEffect ||
+                $root.implicitSideEffectStep === $sideEffect ||
+                (0, index_js_1.stepADependsOnStepB)($root, $sideEffect)) {
+                // It's marked readonly, but we override it anyway
+                this.sideEffectStep = null;
+            }
+        }
         // Build the executor
         switch (this.type.mode) {
             case "null": {
@@ -372,12 +339,8 @@ class OutputPlan {
                             spec.outputPlan.layerPlan.id === this.layerPlan.id,
                     };
                 }
-                makeObjectExecutor(type.typeName, digestFieldTypes, this.deferredOutputPlans.length > 0, type.mode === "root", false, (fn) => {
-                    this.execute = fn;
-                });
-                makeObjectExecutor(type.typeName, digestFieldTypes, this.deferredOutputPlans.length > 0, type.mode === "root", true, (fn) => {
-                    this.executeString = fn;
-                });
+                this.execute = makeObjectExecutor(type.typeName, digestFieldTypes, this.deferredOutputPlans.length > 0, type.mode === "root", false);
+                this.executeString = makeObjectExecutor(type.typeName, digestFieldTypes, this.deferredOutputPlans.length > 0, type.mode === "root", true);
                 break;
             }
             default: {
@@ -399,10 +362,9 @@ function coerceError(error, locationDetails, path) {
         }
     }
     else {
-        return new GraphQLError(error.message, locationDetails.node, null, null, path, error, null);
+        return new GraphQLError(error?.message ?? String(error), locationDetails.node, null, null, path, error, null);
     }
 }
-exports.coerceError = coerceError;
 function nonNullError(locationDetails, path) {
     const { parentTypeName, fieldName, node } = locationDetails;
     if (!parentTypeName || !fieldName) {
@@ -410,7 +372,6 @@ function nonNullError(locationDetails, path) {
     }
     return new GraphQLError(`Cannot return null for non-nullable field ${parentTypeName}.${fieldName}.`, node, null, null, path, null, null);
 }
-exports.nonNullError = nonNullError;
 /**
  * We're currently running OutputPlan `outputPlan` in bucket `bucket` at index
  * `bucketIndex`. If this is an array OutputPlan then we're looping over the
@@ -422,17 +383,20 @@ exports.nonNullError = nonNullError;
  *
  * @internal
  */
-function getChildBucketAndIndex(childOutputPlan, outputPlan, bucket, bucketIndex, arrayIndex = null) {
+function getChildBucketAndIndex(layerPlan, outputPlan, bucket, bucketIndex, arrayIndex = null) {
+    if (bucket.layerPlan === layerPlan) {
+        return [bucket, bucketIndex];
+    }
     if ((arrayIndex == null) ===
         (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 && childOutputPlan.layerPlan === bucket.layerPlan) {
+    if (outputPlan != null && layerPlan === bucket.layerPlan) {
         // Same layer; straightforward
         return [bucket, bucketIndex];
     }
-    const reversePath = [childOutputPlan.layerPlan];
-    let current = childOutputPlan.layerPlan;
+    const reversePath = [layerPlan];
+    let current = layerPlan;
     while (!bucket.children[current.id]) {
         current = current.parentLayerPlan;
         if (!current) {
@@ -485,71 +449,112 @@ function getChildBucketAndIndex(childOutputPlan, outputPlan, bucket, bucketIndex
     }
     return [currentBucket, currentIndex];
 }
-exports.getChildBucketAndIndex = getChildBucketAndIndex;
-function makeExecutorExpression(options) {
-    const { inner, nameExtra, asString, skipNullHandling = false, preamble = tamedevil_1.default.blank, } = options;
-    return (0, tamedevil_1.default) `\
-(function compiledOutputPlan${asString ? te_String : tamedevil_1.default.blank}_${nameExtra}(
-  root,
-  mutablePath,
-  bucket,
-  bucketIndex,
-  rawBucketRootValue = bucket.store.get(this.rootStep.id)[bucketIndex]
-) {
-  const bucketRootValue = this.processRoot !== null ? this.processRoot(rawBucketRootValue) : rawBucketRootValue;
-${preamble}\
-  ${skipNullHandling
-        ? dev_js_1.isDev
-            ? te_nullIsFineComment
-            : tamedevil_1.default.blank
-        : (0, tamedevil_1.default) `if (bucketRootValue == null) return ${asString ? te_nullString : te_null};`}
-  if (bucketRootValue${skipNullHandling ? te_questionDot : tamedevil_1.default.blank}[${ref_$$error}]) {
-    throw ${ref_coerceError}(bucketRootValue.originalError, this.locationDetails, mutablePath.slice(1));
-  }
-${inner}
-})`;
+function makeExecutor(config) {
+    const { preamble = null, inner, asString, nameExtra, skipNullHandling = false, } = config;
+    const fn = function (root, mutablePath, bucket, bucketIndex, rawBucketRootValue = bucket.store.get(this.rootStep.id).at(bucketIndex), bucketRootFlags = bucket.store.get(this.rootStep.id)._flagsAt(bucketIndex)) {
+        if (this.sideEffectStep !== null) {
+            const sideEffectBucketDetails = getChildBucketAndIndex(this.sideEffectStep.layerPlan, null, bucket, bucketIndex);
+            if (sideEffectBucketDetails) {
+                const [sideEffectBucket, sideEffectBucketIndex] = sideEffectBucketDetails;
+                const ev = sideEffectBucket.store.get(this.sideEffectStep.id);
+                if (!ev) {
+                    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) {
+                    const seVal = ev.at(sideEffectBucketIndex);
+                    throw coerceError(seVal, this.locationDetails, mutablePath.slice(1));
+                }
+            }
+        }
+        if (bucketRootFlags & interfaces_js_1.FLAG_ERROR) {
+            throw coerceError(rawBucketRootValue, this.locationDetails, mutablePath.slice(1));
+        }
+        const bucketRootValue = this.processRoot !== null
+            ? this.processRoot(rawBucketRootValue, bucketRootFlags)
+            : rawBucketRootValue;
+        const earlyReturn = preamble?.call(this, bucketRootValue);
+        if (earlyReturn !== undefined) {
+            return earlyReturn;
+        }
+        if (!skipNullHandling) {
+            if (bucketRootValue == null)
+                return (asString ? "null" : null);
+        }
+        return inner.call(this, bucketRootValue, root, mutablePath, bucket, bucketIndex, rawBucketRootValue, bucketRootFlags);
+    };
+    fn.displayName = `outputPlan${asString ? "String" : ""}_${nameExtra}`;
+    return fn;
 }
-function makeExecutor(options, callback) {
-    const expression = makeExecutorExpression(options);
-    if (callback !== undefined) {
-        tamedevil_1.default.runInBatch(expression, callback);
-    }
-    else {
-        return tamedevil_1.default.run((0, tamedevil_1.default) `return ${expression}`);
+function executeChildPlan(that, locationDetails, childOutputPlan, isNonNull, asString, childBucket, childBucketIndex, bucket, bucketIndex, mutablePath, mutablePathIndex, root, rawBucketRootValue, bucketRootFlags) {
+    const $sideEffect = childOutputPlan.layerPlan.parentSideEffectStep;
+    if ($sideEffect !== null) {
+        // Check if there's an error
+        const sideEffectBucketDetails = getChildBucketAndIndex($sideEffect.layerPlan, null, bucket, bucketIndex);
+        if (sideEffectBucketDetails) {
+            const [sideEffectBucket, sideEffectBucketIndex] = sideEffectBucketDetails;
+            const ev = sideEffectBucket.store.get($sideEffect.id);
+            if (!ev) {
+                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) {
+                const e = coerceError(ev.at(sideEffectBucketIndex), locationDetails, mutablePath.slice(1));
+                if (isNonNull) {
+                    throw e;
+                }
+                else {
+                    const streamCount = root.streams.length;
+                    const queueCount = root.queue.length;
+                    commonErrorHandler(e, locationDetails, mutablePath, mutablePathIndex, root, streamCount, queueCount);
+                    return asString ? "null" : null;
+                }
+            }
+        }
     }
-}
-function makeExecuteChildPlanCode(setTargetOrReturn, locationDetails, childOutputPlan, isNonNull, asString, childBucket = te_childBucket, childBucketIndex = te_childBucketIndex) {
-    const te_childOutputPlanExecute = (0, tamedevil_1.default) `${childOutputPlan}.${asString ? te_executeString : te_execute}(root, mutablePath, ${childBucket}, ${childBucketIndex}, ${childBucket}.rootStep === this.rootStep ? rawBucketRootValue : undefined)`;
     // This is the code that changes based on if the field is nullable or not
     if (isNonNull) {
         // No need to catch error
-        return (0, tamedevil_1.default) `\
-  ${childBucket === te_bucket
-            ? tamedevil_1.default.blank
-            : (0, tamedevil_1.default) `if (${childBucket} == null) {
-    throw ${ref_nonNullError}(${locationDetails}, mutablePath.slice(1));
-  }
-  `}fieldResult = ${te_childOutputPlanExecute};
-  if (fieldResult == ${asString ? te_nullString : te_null}) {
-    throw ${ref_nonNullError}(${locationDetails}, mutablePath.slice(1));
-  }
-  ${setTargetOrReturn} fieldResult;`;
+        if (childBucket === bucket) {
+            //noop
+        }
+        else {
+            if (childBucket == null) {
+                throw nonNullError(locationDetails, mutablePath.slice(1));
+            }
+        }
+        const fieldResult = childOutputPlan[asString ? "executeString" : "execute"](root, mutablePath, childBucket, childBucketIndex, 
+        // NOTE: the previous code may have had a bug here, it referenced childBucket.rootStep
+        childOutputPlan.rootStep === that.rootStep
+            ? rawBucketRootValue
+            : undefined, childOutputPlan.rootStep === that.rootStep ? bucketRootFlags : undefined);
+        if (fieldResult == (asString ? "null" : null)) {
+            throw nonNullError(locationDetails, mutablePath.slice(1));
+        }
+        return fieldResult;
     }
     else {
         // Need to catch error and set null
-        return (0, tamedevil_1.default) `\
-  {
-    const streamCount = root.streams.length;
-    const queueCount = root.queue.length;
-    try {
-      ${setTargetOrReturn} ${childBucket === te_bucket
-            ? tamedevil_1.default.blank
-            : (0, tamedevil_1.default) `${childBucket} == null ? ${asString ? te_nullString : te_null} : `}${te_childOutputPlanExecute};
-    } catch (e) {
-      ${te_commonErrorHandler}(e, ${locationDetails}, mutablePath, mutablePathIndex, root, streamCount, queueCount);
-      ${setTargetOrReturn} ${asString ? te_nullString : te_null};
-    }
-  }`;
+        const streamCount = root.streams.length;
+        const queueCount = root.queue.length;
+        try {
+            if (childBucket !== bucket && childBucket == null) {
+                return asString ? "null" : null;
+            }
+            else {
+                return childOutputPlan[asString ? "executeString" : "execute"](root, mutablePath, childBucket, childBucketIndex, 
+                // NOTE: the previous code may have had a bug here, it referenced childBucket.rootStep
+                childOutputPlan.rootStep === that.rootStep
+                    ? rawBucketRootValue
+                    : undefined, childOutputPlan.rootStep === that.rootStep
+                    ? bucketRootFlags
+                    : undefined);
+            }
+        }
+        catch (e) {
+            commonErrorHandler(e, locationDetails, mutablePath, mutablePathIndex, root, streamCount, queueCount);
+            return asString ? "null" : null;
+        }
     }
 }
 function commonErrorHandler(e, locationDetails, mutablePath, mutablePathIndex, root, streamCount, queueCount) {
@@ -567,97 +572,94 @@ function commonErrorHandler(e, locationDetails, mutablePath, mutablePathIndex, r
     }
     root.errors.push(error);
 }
-/*
- * Below here we create the executors that can be shared across many different
- * OutputPlans without having to be recreated (thus saving significant memory,
- * and increasing the probability of optimization).
- */
 const nullExecutor = makeExecutor({
-    inner: tamedevil_1.default.cache `  return null;`,
-    nameExtra: tamedevil_1.default.cache `null`,
+    inner: () => null,
+    nameExtra: "null",
     asString: false,
 });
 const nullExecutorString = makeExecutor({
-    inner: tamedevil_1.default.cache `  return "null";`,
-    nameExtra: tamedevil_1.default.cache `null`,
+    inner: () => "null",
+    nameExtra: `null`,
     asString: true,
 });
 /* This is what leafExecutor should use if insideGraphQL (which isn't currently
- * supported)
-`\
-  if (root.insideGraphQL) {
-    // Don't serialize to avoid the double serialization problem
-    return bucketRootValue;
-  } else {
-    return this.type.graphqlType.serialize(bucketRootValue);
-  }
-` */
+   * supported)
+  `\
+    if (root.insideGraphQL) {
+      // Don't serialize to avoid the double serialization problem
+      return bucketRootValue;
+    } else {
+      return this.type.graphqlType.serialize(bucketRootValue);
+    }
+  ` */
 const leafExecutor = makeExecutor({
-    inner: (0, tamedevil_1.default) `\
-  return this.type.graphqlType.serialize(bucketRootValue);
-`,
-    nameExtra: tamedevil_1.default.cache `leaf`,
+    inner(bucketRootValue) {
+        return this.type.graphqlType.serialize(bucketRootValue);
+    },
+    nameExtra: `leaf`,
     asString: false,
 });
 const leafExecutorString = makeExecutor({
-    inner: (0, tamedevil_1.default) `\
-  return ${ref_stringifyJSON}(this.type.graphqlType.serialize(bucketRootValue));
-`,
-    nameExtra: tamedevil_1.default.cache `leaf`,
+    inner(bucketRootValue) {
+        return (0, tamedevil_1.stringifyJSON)(this.type.graphqlType.serialize(bucketRootValue));
+    },
+    nameExtra: `leaf`,
     asString: true,
 });
 const booleanLeafExecutorString = makeExecutor({
-    inner: (0, tamedevil_1.default) `\
-  const val = this.type.graphqlType.serialize(bucketRootValue);
-  return val === true ? 'true' : 'false';
-`,
-    nameExtra: tamedevil_1.default.cache `booleanLeaf`,
+    inner(bucketRootValue) {
+        const val = this.type.graphqlType.serialize(bucketRootValue);
+        return val === true ? "true" : "false";
+    },
+    nameExtra: `booleanLeaf`,
     asString: true,
     skipNullHandling: false,
-    preamble: (0, tamedevil_1.default) `\
-  if (bucketRootValue === true) return 'true';
-  if (bucketRootValue === false) return 'false';
-`,
+    preamble(bucketRootValue) {
+        if (bucketRootValue === true)
+            return "true";
+        if (bucketRootValue === false)
+            return "false";
+    },
 });
 const intLeafExecutorString = makeExecutor({
-    inner: (0, tamedevil_1.default) `\
-  return '' + this.type.graphqlType.serialize(bucketRootValue);
-`,
-    nameExtra: tamedevil_1.default.cache `intLeaf`,
+    inner(bucketRootValue) {
+        return "" + this.type.graphqlType.serialize(bucketRootValue);
+    },
+    nameExtra: `intLeaf`,
     asString: true,
     skipNullHandling: false,
     // Fast check to see if number is 32 bit integer
-    preamble: (0, tamedevil_1.default) `\
-  if ((bucketRootValue | 0) === bucketRootValue) {
-    return '' + bucketRootValue;
-  }
-`,
+    preamble(bucketRootValue) {
+        if ((bucketRootValue | 0) === bucketRootValue) {
+            return "" + bucketRootValue;
+        }
+    },
 });
 const floatLeafExecutorString = makeExecutor({
-    inner: (0, tamedevil_1.default) `\
-  return String(this.type.graphqlType.serialize(bucketRootValue));
-`,
-    nameExtra: tamedevil_1.default.cache `floatLeaf`,
+    inner(bucketRootValue) {
+        return String(this.type.graphqlType.serialize(bucketRootValue));
+    },
+    nameExtra: `floatLeaf`,
     asString: true,
     skipNullHandling: false,
-    preamble: (0, tamedevil_1.default) `\
-  if (Number.isFinite(bucketRootValue)) {
-    return '' + bucketRootValue;
-  }
-`,
+    preamble(bucketRootValue) {
+        if (Number.isFinite(bucketRootValue)) {
+            return "" + bucketRootValue;
+        }
+    },
 });
 const stringLeafExecutorString = makeExecutor({
-    inner: (0, tamedevil_1.default) `\
-  return ${ref_stringifyString}(this.type.graphqlType.serialize(bucketRootValue));
-`,
-    nameExtra: tamedevil_1.default.cache `stringLeaf`,
+    inner(bucketRootValue) {
+        return (0, tamedevil_1.stringifyString)(this.type.graphqlType.serialize(bucketRootValue));
+    },
+    nameExtra: `stringLeaf`,
     asString: true,
     skipNullHandling: false,
-    preamble: (0, tamedevil_1.default) `\
-  if (typeof bucketRootValue === 'string') {
-    return ${ref_stringifyString}(bucketRootValue);
-  }
-`,
+    preamble(bucketRootValue) {
+        if (typeof bucketRootValue === "string") {
+            return (0, tamedevil_1.stringifyString)(bucketRootValue);
+        }
+    },
 });
 // NOTE: the reference to $$concreteType here is a (temporary) optimization; it
 // should be `resolveType(bucketRootValue)` but it's not worth the function
@@ -665,53 +667,32 @@ const stringLeafExecutorString = makeExecutor({
 // store.
 function makePolymorphicExecutor(asString) {
     return makeExecutor({
-        inner: (0, tamedevil_1.default) `\
-${dev_js_1.isDev
-            ? (0, tamedevil_1.default) `\
-  if (!${ref_isPolymorphicData}(bucketRootValue)) {
-    throw ${ref_coerceError}(
-      new Error(
-        "GrafastInternalError<db7fcda5-dc39-4568-a7ce-ee8acb88806b>: Expected polymorphic data",
-      ),
-      this.locationDetails,
-      mutablePath.slice(1),
-    );
-  }
-`
-            : tamedevil_1.default.blank}\
-  const typeName = bucketRootValue[${ref_$$concreteType}];
-  const childOutputPlan = this.childByTypeName[typeName];
-  ${dev_js_1.isDev
-            ? (0, tamedevil_1.default) `{
-    ${ref_assert}.ok(
-      typeName,
-      "GrafastInternalError<fd3f3cf0-0789-4c74-a6cd-839c808896ed>: Could not determine concreteType for object",
-    );
-    ${ref_assert}.ok(
-      childOutputPlan,
-      \`GrafastInternalError<a46999ef-41ff-4a22-bae9-fa37ff6e5f7f>: Could not determine the OutputPlan to use for '\${typeName}' from '\${bucket.layerPlan}'\`,
-    );
-  }`
-            : tamedevil_1.default.blank}
-
-  const directChild = bucket.children[childOutputPlan.layerPlan.id];
-  if (directChild !== undefined) {
-    return childOutputPlan.${asString ? te_executeString : te_execute}(root, mutablePath, directChild.bucket, directChild.map.get(bucketIndex));
-  } else {
-    const c = ${ref_getChildBucketAndIndex}(
-      childOutputPlan,
-      this,
-      bucket,
-      bucketIndex,
-    );
-    if (!c) {
-      throw new Error("GrafastInternalError<691509d8-31fa-4cfe-a6df-dcba21bd521f>: polymorphic executor couldn't determine child bucket");
-    }
-    const [childBucket, childBucketIndex] = c;
-    return childOutputPlan.${asString ? te_executeString : te_execute}(root, mutablePath, childBucket, childBucketIndex);
-  }
-`,
-        nameExtra: te_polymorphic,
+        inner(bucketRootValue, root, mutablePath, bucket, bucketIndex) {
+            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));
+                }
+            }
+            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}'`);
+            }
+            const directChild = bucket.children[childOutputPlan.layerPlan.id];
+            if (directChild !== undefined) {
+                return childOutputPlan[asString ? "executeString" : "execute"](root, mutablePath, directChild.bucket, directChild.map.get(bucketIndex));
+            }
+            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");
+                }
+                const [childBucket, childBucketIndex] = c;
+                return childOutputPlan[asString ? "executeString" : "execute"](root, mutablePath, childBucket, childBucketIndex);
+            }
+        },
+        nameExtra: "polymorphic",
         asString,
     });
 }
@@ -719,75 +700,94 @@ const polymorphicExecutor = makePolymorphicExecutor(false);
 const polymorphicExecutorString = makePolymorphicExecutor(true);
 function makeArrayExecutor(childIsNonNull, canStream, asString) {
     return makeExecutor({
-        inner: (0, tamedevil_1.default) `\
-  if (!Array.isArray(bucketRootValue)) {
-    console.warn(\`Hit fallback for value \${${ref_inspect}(bucketRootValue)} coercion to mode 'array'\`);
-    return ${asString ? te_nullString : te_null};
-  }
-
-  const childOutputPlan = this.child;
-  const l = bucketRootValue.length;
-  let fieldResult;
-  ${asString ? te_letString : te_constDataEqualsEmptyArray}
-  if (l === 0) {
-${asString ? te_stringEqualsEmptyArrayString : te_noopComment}
-  } else {
-${asString ? te_stringEqualsLeftSquareBraceString : tamedevil_1.default.blank}\
-    const mutablePathIndex = mutablePath.push(-1) - 1;
-
-    // Now to populate the children...
-    const directChild = bucket.children[childOutputPlan.layerPlan.id];
-    let childBucket, childBucketIndex, lookup;
-    if (directChild !== undefined) {
-      childBucket = directChild.bucket;
-      lookup = directChild.map.get(bucketIndex)
-    }
-    for (let i = 0; i < l; i++) {
-      if (directChild !== undefined) {
-        childBucketIndex = lookup[i];
-      } else {
-        const c = ${ref_getChildBucketAndIndex}(
-          childOutputPlan,
-          this,
-          bucket,
-          bucketIndex,
-          i,
-        );
-        if (c !== null) {
-          ([childBucket, childBucketIndex] = c);
-        } else {
-          childBucket = childBucketIndex = null;
-        }
-      }
-
-      mutablePath[mutablePathIndex] = i;
-${asString ? te_ifIGt0StrPlusEqualComma : tamedevil_1.default.blank}
-${makeExecuteChildPlanCode(asString ? te_stringPlusEquals : te_dataIEquals, te_thisDotLocationDetails, te_childOutputPlan, childIsNonNull, asString)}
-    }
-
-    mutablePath.length = mutablePathIndex;
-${asString ? te_stringPlusEqualsRbracket : tamedevil_1.default.blank}
-  }
-${canStream
-            ? (0, tamedevil_1.default) `\
-  const stream = bucketRootValue[${ref_$$streamMore}] /* as | AsyncIterableIterator<any> | undefined*/;
-  if (stream !== undefined) {
-    root.streams.push({
-      root,
-      path: mutablePath.slice(1),
-      bucket,
-      bucketIndex,
-      outputPlan: childOutputPlan,
-      label: childOutputPlan.layerPlan.reason.stream?.label,
-      stream,
-      startIndex: bucketRootValue.length,
-    });
-  }`
-            : tamedevil_1.default.blank}
-
-  return ${asString ? te_string : te_data};
-`,
-        nameExtra: (0, tamedevil_1.default) `array${childIsNonNull ? te_underscoreNonNull : tamedevil_1.default.blank}${canStream ? te_underscoreStream : tamedevil_1.default.blank}`,
+        inner(bucketRootValue, root, mutablePath, bucket, bucketIndex, rawBucketRootValue, bucketRootFlags) {
+            if (!Array.isArray(bucketRootValue)) {
+                console.warn(`Hit fallback for value ${(0, inspect_js_1.inspect)(bucketRootValue)} coercion to mode 'array'`);
+                return (asString ? "null" : null);
+            }
+            if (this.child === null) {
+                throw new Error(`GrafastInternalError<365fd45e-2939-411b-92a6-4f6875d8fbd3>: ${this} has no child output plan?!`);
+            }
+            const childOutputPlan = this.child;
+            const l = bucketRootValue.length;
+            let string;
+            let data;
+            if (l === 0) {
+                if (asString) {
+                    string = "[]";
+                }
+                else {
+                    data = [];
+                }
+            }
+            else {
+                if (asString) {
+                    string = "[";
+                }
+                else {
+                    data = [];
+                }
+                const mutablePathIndex = mutablePath.push(-1) - 1;
+                // Now to populate the children...
+                const directChild = bucket.children[childOutputPlan.layerPlan.id];
+                let childBucket, childBucketIndex, lookup;
+                if (directChild !== undefined) {
+                    childBucket = directChild.bucket;
+                    lookup = directChild.map.get(bucketIndex);
+                }
+                for (let i = 0; i < l; i++) {
+                    if (directChild !== undefined) {
+                        childBucketIndex = lookup[i];
+                    }
+                    else {
+                        const c = getChildBucketAndIndex(childOutputPlan.layerPlan, this, bucket, bucketIndex, i);
+                        if (c !== null) {
+                            [childBucket, childBucketIndex] = c;
+                        }
+                        else {
+                            childBucket = childBucketIndex = null;
+                        }
+                    }
+                    mutablePath[mutablePathIndex] = i;
+                    if (asString) {
+                        if (i > 0) {
+                            string += ",";
+                        }
+                    }
+                    const val = executeChildPlan(this, this.locationDetails, childOutputPlan, childIsNonNull, asString, childBucket, childBucketIndex, bucket, bucketIndex, mutablePath, mutablePathIndex, root, rawBucketRootValue, bucketRootFlags);
+                    if (asString) {
+                        string += val;
+                    }
+                    else {
+                        data[i] = val;
+                    }
+                }
+                mutablePath.length = mutablePathIndex;
+                if (asString) {
+                    string += "]";
+                }
+            }
+            if (canStream) {
+                const stream = bucketRootValue[interfaces_js_1.$$streamMore];
+                if (stream !== undefined) {
+                    const labelStepId = childOutputPlan.layerPlan.reason.stream?.labelStepId;
+                    root.streams.push({
+                        root,
+                        path: mutablePath.slice(1),
+                        bucket,
+                        bucketIndex,
+                        outputPlan: childOutputPlan,
+                        label: labelStepId != null
+                            ? bucket.store.get(labelStepId)?.unaryValue()
+                            : undefined,
+                        stream,
+                        startIndex: bucketRootValue.length,
+                    });
+                }
+            }
+            return (asString ? string : data);
+        },
+        nameExtra: `array${childIsNonNull ? "_nonNull" : ""}${canStream ? "_stream" : ""}`,
         asString,
     });
 }
@@ -807,7 +807,7 @@ const arrayExecutorString_nonNullable_streaming = makeArrayExecutor(true, true,
  *
  * ENHANCE: write our own introspection execution!
  */
-const introspect = (root, outputPlan, mutablePath, asString) => {
+function introspect(root, outputPlan, mutablePath, asString) {
     const { locationDetails } = outputPlan;
     const { field: rawField, introspectionCacheByVariableValues, variableNames, } = outputPlan.type;
     const field = {
@@ -840,7 +840,7 @@ const introspect = (root, outputPlan, mutablePath, asString) => {
     const canonical = JSON.stringify(variableValues);
     const cached = introspectionCacheByVariableValues.get(canonical);
     if (cached !== undefined) {
-        return asString ? JSON.stringify(cached) : cached;
+        return (asString ? JSON.stringify(cached) : cached);
     }
     const graphqlResult = executeSync({
         schema: outputPlan.layerPlan.operationPlan.schema,
@@ -861,167 +861,155 @@ const introspect = (root, outputPlan, mutablePath, asString) => {
     }
     const result = graphqlResult.data.a;
     introspectionCacheByVariableValues.set(canonical, result);
-    return asString ? JSON.stringify(result) : result;
-};
-const ref_introspect = tamedevil_1.default.ref(introspect, "introspect");
+    return (asString ? JSON.stringify(result) : result);
+}
 const introspectionExecutor = makeExecutor({
-    inner: (0, tamedevil_1.default) `  return ${ref_introspect}(root, this, mutablePath, false)`,
-    nameExtra: tamedevil_1.default.cache `introspection`,
+    inner(_bucketRootValue, root, mutablePath) {
+        return introspect(root, this, mutablePath, false);
+    },
+    nameExtra: `introspection`,
     asString: false,
     skipNullHandling: true,
 });
 const introspectionExecutorString = makeExecutor({
-    inner: (0, tamedevil_1.default) `  return ${ref_introspect}(root, this, mutablePath, true)`,
-    nameExtra: tamedevil_1.default.cache `introspection`,
+    inner(_bucketRootValue, root, mutablePath) {
+        return introspect(root, this, mutablePath, true);
+    },
+    nameExtra: `introspection`,
     asString: true,
     skipNullHandling: true,
 });
 const SAFE_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
 function makeObjectExecutor(typeName, fieldTypes, hasDeferredOutputPlans, 
 // this.type.mode === "root",
-isRoot, asString, callback) {
+isRoot, asString) {
     if (!SAFE_NAME.test(typeName)) {
         throw new Error(`Unsafe type name: ${typeName}; doesn't conform to 'Name' in the GraphQL spec`);
     }
-    const keys = [];
-    const fieldSpecs = [];
-    let signature = (asString ? "s" : "o") +
-        (isRoot ? "r" : "") +
-        (hasDeferredOutputPlans ? "d" : "");
-    let hasChildBucketReference = false;
-    for (const [key, fieldSpec] of Object.entries(fieldTypes)) {
-        if (!SAFE_NAME.test(key)) {
+    if (dev_js_1.isDev) {
+        if (Object.getPrototypeOf(fieldTypes) !== null) {
+            throw new Error(`GrafastInternalError<3d8e3547-d818-44e1-a076-16b828e3a34d>: fieldTypes must have a null prototype`);
+        }
+    }
+    const fieldDigests = Object.entries(fieldTypes).map(([responseKey, fieldSpec], i) => {
+        // NOTE: this code relies on the fact that fieldName and typeName do
+        // not require any quoting in JSON/JS - they must conform to GraphQL
+        // `Name`.
+        if (!SAFE_NAME.test(responseKey)) {
             // This should not be able to happen if the GraphQL operation is valid
-            throw new Error(`Unsafe key: ${key}; doesn't conform to 'Name' in the GraphQL spec`);
+            throw new Error(`Unsafe key: ${responseKey}; doesn't conform to 'Name' in the GraphQL spec`);
         }
-        keys.push(key);
-        fieldSpecs.push(fieldSpec);
         const { fieldType, sameBucket } = fieldSpec;
+        const addComma = asString && i > 0;
         switch (fieldType) {
             case "__typename": {
-                signature += "_";
-                break;
+                return {
+                    isTypeName: true,
+                    addComma,
+                    responseKey,
+                    stringValue: asString ? `"${responseKey}":"${typeName}"` : null,
+                };
             }
+            case "outputPlan!":
             case "outputPlan?": {
-                signature += "?";
-                break;
-            }
-            case "outputPlan!": {
-                signature += "!";
-                break;
+                return {
+                    isTypeName: false,
+                    addComma,
+                    responseKey,
+                    stringPrefix: asString ? `"${responseKey}":` : null,
+                    sameBucket,
+                    isNonNull: fieldType === "outputPlan!",
+                };
             }
             default: {
                 const never = fieldType;
-                throw new Error(`Unsupported field type '${never}'`);
+                throw new Error(`GrafastInternalError<879082f4-fe6f-4112-814f-852b9932ca83>: unsupported key type ${never}`);
             }
         }
-        if (!sameBucket) {
-            hasChildBucketReference = true;
-            signature += "~";
-        }
-    }
-    withObjectExecutorFactory(signature, fieldSpecs, hasDeferredOutputPlans, isRoot, asString, hasChildBucketReference, (factory) => {
-        const fn = factory(typeName, ...keys);
-        callback(fn);
     });
-}
-const makeObjectExecutorCache = new lru_1.default({
-    maxLength: 1000,
-});
-const makingObjectExecutorCallbacks = new Map();
-function withObjectExecutorFactory(signature, fieldSpecs, hasDeferredOutputPlans, isRoot, asString, hasChildBucketReference, callback) {
-    const fn = makeObjectExecutorCache.get(signature);
-    if (fn !== undefined) {
-        return callback(fn);
-    }
-    const building = makingObjectExecutorCallbacks.get(signature);
-    if (building !== undefined) {
-        building.push(callback);
-        return;
-    }
-    const callbacks = [callback];
-    makingObjectExecutorCallbacks.set(signature, callbacks);
-    const inner = (0, tamedevil_1.default) `\
-  ${asString ? te_letStringLbrace : te_constObjEqualsObjectCreateNull}
-  const { keys } = this;
-  const mutablePathIndex = mutablePath.push("!") - 1;
-  let spec${hasChildBucketReference ? te_childBucketCBIDC : tamedevil_1.default.blank}, fieldResult;
-
-${tamedevil_1.default.join(fieldSpecs.map(({ fieldType, sameBucket }, i) => {
-        const te_fieldNameI = tamedevil_1.default.identifier(`fieldName_${i}`);
-        switch (fieldType) {
-            case "__typename": {
-                if (asString) {
-                    // NOTE: this code relies on the fact that fieldName and typeName do
-                    // not require any quoting in JSON/JS - they must conform to GraphQL
-                    // `Name`.
-                    return (0, tamedevil_1.default) `  string += \`${i === 0 ? tamedevil_1.default.blank : te_comma}"\${${te_fieldNameI}}":"\${typeName}"\`;\n`;
+    return makeExecutor({
+        inner(bucketRootValue, root, mutablePath, bucket, bucketIndex, rawBucketRootValue, bucketRootFlags) {
+            let string = asString ? "{" : undefined;
+            const obj = asString
+                ? undefined
+                : Object.create(null);
+            const keys = this.keys;
+            const mutablePathIndex = mutablePath.push("!") - 1;
+            for (const digest of fieldDigests) {
+                if (digest.addComma) {
+                    string += ",";
+                }
+                const responseKey = digest.responseKey;
+                if (digest.isTypeName) {
+                    if (asString) {
+                        string += digest.stringValue;
+                    }
+                    else {
+                        obj[responseKey] = typeName;
+                    }
                 }
                 else {
-                    return (0, tamedevil_1.default) `  obj[${te_fieldNameI}] = typeName;\n`;
+                    mutablePath[mutablePathIndex] = responseKey;
+                    const spec = keys[responseKey];
+                    if (digest.sameBucket) {
+                        const val = executeChildPlan(this, spec.locationDetails, spec.outputPlan, digest.isNonNull, asString, bucket, bucketIndex, bucket, bucketIndex, mutablePath, mutablePathIndex, root, rawBucketRootValue, bucketRootFlags);
+                        if (asString) {
+                            string += digest.stringPrefix;
+                            string += val;
+                        }
+                        else {
+                            obj[responseKey] = val;
+                        }
+                    }
+                    else {
+                        const directChild = bucket.children[spec.outputPlan.layerPlan.id];
+                        let childBucket, childBucketIndex;
+                        if (directChild !== undefined) {
+                            childBucket = directChild.bucket;
+                            childBucketIndex = directChild.map.get(bucketIndex);
+                        }
+                        else {
+                            const c = getChildBucketAndIndex(spec.outputPlan.layerPlan, this, bucket, bucketIndex);
+                            if (c !== null) {
+                                [childBucket, childBucketIndex] = c;
+                            }
+                            else {
+                                childBucket = childBucketIndex = null;
+                            }
+                        }
+                        const val = executeChildPlan(this, spec.locationDetails, spec.outputPlan, digest.isNonNull, asString, childBucket, childBucketIndex, bucket, bucketIndex, mutablePath, mutablePathIndex, root, rawBucketRootValue, bucketRootFlags);
+                        if (asString) {
+                            string += digest.stringPrefix;
+                            string += val;
+                        }
+                        else {
+                            obj[responseKey] = val;
+                        }
+                    }
                 }
             }
-            case "outputPlan!":
-            case "outputPlan?": {
-                return (0, tamedevil_1.default) `\
-  mutablePath[mutablePathIndex] = ${te_fieldNameI};
-  spec = keys[${te_fieldNameI}];
-${asString
-                    ? (0, tamedevil_1.default) `  string += \`${i === 0 ? tamedevil_1.default.blank : te_comma}"\${${te_fieldNameI}}":\`;
-`
-                    : tamedevil_1.default.blank}\
-${sameBucket
-                    ? (0, tamedevil_1.default) `\
-${makeExecuteChildPlanCode(asString ? te_stringPlusEquals : (0, tamedevil_1.default) `obj[${te_fieldNameI}] =`, te_specDotLocationDetails, te_specDotOutputPlan, fieldType === "outputPlan!", asString, te_bucket, te_bucketIndex)}`
-                    : (0, tamedevil_1.default) `\
-  directChild = bucket.children[spec.outputPlan.layerPlanId];
-  if (directChild !== undefined) {
-    childBucket = directChild.bucket;
-    childBucketIndex = directChild.map.get(bucketIndex);
-  } else {
-    const c = ${ref_getChildBucketAndIndex}(
-      spec.outputPlan,
-      this,
-      bucket,
-      bucketIndex,
-    );
-    if (c !== null) {
-      ([childBucket, childBucketIndex] = c);
-    } else {
-      childBucket = childBucketIndex = null;
-    }
-  }
-${makeExecuteChildPlanCode(asString ? te_stringPlusEquals : (0, tamedevil_1.default) `obj[${te_fieldNameI}] =`, te_specDotLocationDetails, te_specDotOutputPlan, fieldType === "outputPlan!", asString)}`}
-`;
+            mutablePath.length = mutablePathIndex;
+            if (asString) {
+                string += "}";
             }
-            default: {
-                const never = fieldType;
-                throw new Error(`GrafastInternalError<879082f4-fe6f-4112-814f-852b9932ca83>: unsupported key type ${never}`);
+            if (hasDeferredOutputPlans) {
+                // Everything seems okay; queue any deferred payloads
+                for (const defer of this.deferredOutputPlans) {
+                    root.queue.push({
+                        root,
+                        path: mutablePath.slice(1),
+                        bucket,
+                        bucketIndex,
+                        outputPlan: defer,
+                        label: defer.type.deferLabel,
+                    });
+                }
             }
-        }
-    }), "\n")}
-
-  mutablePath.length = mutablePathIndex;
-${asString ? te_stringPlusEqualsRbrace : tamedevil_1.default.blank}\
-${hasDeferredOutputPlans ? te_handleDeferred : tamedevil_1.default.blank}
-  return ${asString ? te_string : te_obj};`;
-    const executorExpression = makeExecutorExpression({
-        inner: inner,
-        nameExtra: te_object,
+            return (asString ? string : obj);
+        },
+        nameExtra: "object",
         asString,
         skipNullHandling: isRoot,
-        preamble: tamedevil_1.default.blank,
-    });
-    const factoryExpression = (0, tamedevil_1.default) `\
-function objectExecutorFactory(typeName${tamedevil_1.default.join(fieldSpecs.map((_, i) => (0, tamedevil_1.default) `, ${tamedevil_1.default.identifier(`fieldName_${i}`)}`), "")}) {
-  return ${executorExpression};
-}`;
-    tamedevil_1.default.runInBatch(factoryExpression, (factory) => {
-        makeObjectExecutorCache.set(signature, factory);
-        makingObjectExecutorCallbacks.delete(signature);
-        for (const callback of callbacks) {
-            callback(factory);
-        }
     });
 }
 const makeCache = new lru_1.default({