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

package/dist/steps/error.d.ts

@@ -1,6 +1,6 @@
-import type { GrafastResultsList } from "../interfaces.js";
-import { UnbatchedExecutableStep } from "../step.js";
-export declare class ErrorStep<TError extends Error> extends UnbatchedExecutableStep<never> {
+import type { ExecutionDetails, GrafastResultsList } from "../interfaces.js";
+import { UnbatchedStep } from "../step.js";
+export declare class ErrorStep<TError extends Error> extends UnbatchedStep<never> {
     static $$export: {
         moduleName: string;
         exportName: string;
@@ -8,7 +8,7 @@ export declare class ErrorStep<TError extends Error> extends UnbatchedExecutable
     isSyncAndSafe: boolean;
     error: TError;
     constructor(error: TError);
-    execute(count: number): GrafastResultsList<any>;
+    execute({ count }: ExecutionDetails): GrafastResultsList<any>;
     unbatchedExecute(): any;
 }
 export declare function error<TError extends Error>(error: TError): ErrorStep<TError>;

package/dist/steps/error.js

@@ -1,10 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.error = exports.ErrorStep = void 0;
+exports.ErrorStep = void 0;
+exports.error = error;
+const error_js_1 = require("../error.js");
 const inspect_js_1 = require("../inspect.js");
 const step_js_1 = require("../step.js");
 const utils_js_1 = require("../utils.js");
-class ErrorStep extends step_js_1.UnbatchedExecutableStep {
+class ErrorStep extends step_js_1.UnbatchedStep {
     static { this.$$export = {
         moduleName: "grafast",
         exportName: "ErrorStep",
@@ -17,16 +19,15 @@ class ErrorStep extends step_js_1.UnbatchedExecutableStep {
         }
         this.error = error;
     }
-    execute(count) {
-        return (0, utils_js_1.arrayOfLength)(count, this.error);
+    execute({ count }) {
+        return (0, utils_js_1.arrayOfLength)(count, (0, error_js_1.flagError)(this.error));
     }
     unbatchedExecute() {
-        return this.error;
+        return (0, error_js_1.flagError)(this.error);
     }
 }
 exports.ErrorStep = ErrorStep;
 function error(error) {
     return new ErrorStep(error);
 }
-exports.error = error;
 //# sourceMappingURL=error.js.map

package/dist/steps/filter.d.ts

@@ -1,10 +1,11 @@
-import type { ExecutableStep, ListCapableStep } from "../step.js";
+import type { ListCapableStep, Step } from "../step.js";
 import type { __ItemStep } from "./__item.js";
+import type { ConnectionCapableStep, ItemsStep } from "./connection.js";
 import type { __ListTransformStep, ListTransformItemPlanCallback } from "./listTransform.js";
 export type FilterPlanMemo = unknown[];
 /**
  * Filters a list plan to only include entries for which the `filterCallback`
  * plan results in a truthy value.
  */
-export declare function filter<TListStep extends ExecutableStep<readonly any[]>, TItemStep extends ExecutableStep<boolean>>(listStep: TListStep, filterCallback: ListTransformItemPlanCallback<TListStep, TItemStep>): __ListTransformStep<TListStep, TItemStep, FilterPlanMemo, TListStep extends ListCapableStep<any, any> ? ReturnType<TListStep["listItem"]> : __ItemStep<any>>;
+export declare function filter<TListStep extends Step<readonly any[]> | ConnectionCapableStep<any, any>, TItemStep extends Step<boolean>>(listStep: TListStep, filterCallback: ListTransformItemPlanCallback<ItemsStep<TListStep>, TItemStep>): __ListTransformStep<TListStep, TItemStep, FilterPlanMemo, TListStep extends ListCapableStep<any, any> ? ReturnType<TListStep["listItem"]> : __ItemStep<any>>;
 //# sourceMappingURL=filter.d.ts.map

package/dist/steps/filter.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.filter = void 0;
+exports.filter = filter;
 const tslib_1 = require("tslib");
 const chalk_1 = tslib_1.__importDefault(require("chalk"));
 const step_js_1 = require("../step.js");
@@ -28,5 +28,4 @@ function filter(listStep, filterCallback) {
         meta: `filter:${chalk_1.default.yellow(listStep.id)}${filterCallback.name ? `/${filterCallback.name}` : ""}`,
     });
 }
-exports.filter = filter;
 //# sourceMappingURL=filter.js.map

package/dist/steps/first.d.ts

@@ -1,22 +1,23 @@
-import type { ExecutionExtra, GrafastResultsList, GrafastValuesList } from "../interfaces.js";
-import type { ExecutableStep } from "../step.js";
-import { UnbatchedExecutableStep } from "../step.js";
-export declare class FirstStep<TData> extends UnbatchedExecutableStep<TData> {
+import type { ExecutionDetails, GrafastResultsList, UnbatchedExecutionExtra } from "../interfaces.js";
+import type { Step } from "../step.js";
+import { UnbatchedStep } from "../step.js";
+import type { ConnectionCapableStep } from "./connection.js";
+export declare class FirstStep<TData> extends UnbatchedStep<TData> {
     static $$export: {
         moduleName: string;
         exportName: string;
     };
     isSyncAndSafe: boolean;
     allowMultipleOptimizations: boolean;
-    constructor(parentPlan: ExecutableStep<ReadonlyArray<TData>>);
-    execute(count: number, values: GrafastValuesList<[ReadonlyArray<TData>]>): GrafastResultsList<TData>;
-    unbatchedExecute(_extra: ExecutionExtra, list: any[]): any;
+    constructor(parentPlan: Step<ReadonlyArray<TData>> | ConnectionCapableStep<Step<TData>, any>);
+    execute({ indexMap, values: [values0], }: ExecutionDetails<[ReadonlyArray<TData>]>): GrafastResultsList<TData>;
+    unbatchedExecute(_extra: UnbatchedExecutionExtra, list: any[]): any;
     deduplicate(peers: FirstStep<TData>[]): FirstStep<TData>[];
-    optimize(): ExecutableStep<any> | this;
+    optimize(): any;
 }
 /**
  * A plan that resolves to the first entry in the list returned by the given
  * plan.
  */
-export declare function first<TData>(plan: ExecutableStep<ReadonlyArray<TData>>): FirstStep<TData>;
+export declare function first<TData>(plan: Step<ReadonlyArray<TData>> | ConnectionCapableStep<Step<TData>, any>): FirstStep<TData>;
 //# sourceMappingURL=first.d.ts.map

package/dist/steps/first.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.first = exports.FirstStep = void 0;
+exports.FirstStep = void 0;
+exports.first = first;
 const step_js_1 = require("../step.js");
+const connection_js_1 = require("./connection.js");
 const list_js_1 = require("./list.js");
-class FirstStep extends step_js_1.UnbatchedExecutableStep {
+class FirstStep extends step_js_1.UnbatchedStep {
     static { this.$$export = {
         moduleName: "grafast",
         exportName: "FirstStep",
@@ -12,15 +14,10 @@ class FirstStep extends step_js_1.UnbatchedExecutableStep {
         super();
         this.isSyncAndSafe = true;
         this.allowMultipleOptimizations = true;
-        this.addDependency(parentPlan);
+        this.addDependency((0, connection_js_1.itemsOrStep)(parentPlan));
     }
-    execute(count, values) {
-        const result = [];
-        const dep = values[0];
-        for (let i = 0; i < count; i++) {
-            result[i] = dep[i]?.[0];
-        }
-        return result;
+    execute({ indexMap, values: [values0], }) {
+        return indexMap((i) => values0.at(i)?.[0]);
     }
     unbatchedExecute(_extra, list) {
         return list?.[0];
@@ -32,7 +29,7 @@ class FirstStep extends step_js_1.UnbatchedExecutableStep {
         const parent = this.getDep(0);
         // The first of a list plan is just the first dependency of the list plan.
         if (parent instanceof list_js_1.ListStep) {
-            return parent.getDep(0);
+            return parent.first();
         }
         return this;
     }
@@ -43,7 +40,6 @@ exports.FirstStep = FirstStep;
  * plan.
  */
 function first(plan) {
-    return new FirstStep(plan);
+    return plan.operationPlan.cacheStep(plan, "GrafastInternal:first()", "", () => new FirstStep(plan));
 }
-exports.first = first;
 //# sourceMappingURL=first.js.map

package/dist/steps/graphqlResolver.d.ts

@@ -1,77 +1,4 @@
-import type { GraphQLFieldResolver, GraphQLNullableType, GraphQLOutputType, GraphQLResolveInfo } from "graphql";
-import type { __ItemStep, ObjectStep } from "../index.js";
-import type { ExecutionExtra, GrafastResultsList, GrafastResultStreamList, GrafastValuesList } from "../interfaces.js";
-import type { PolymorphicStep } from "../step.js";
-import { ExecutableStep, UnbatchedExecutableStep } from "../step.js";
-type ResolveInfoBase = Omit<GraphQLResolveInfo, "path" | "rootValue" | "variableValues">;
-/**
- * Calls the given GraphQL resolver for each input - emulates GraphQL
- * resolution.
- *
- * @internal
- */
-export declare class GraphQLResolverStep extends UnbatchedExecutableStep {
-    private resolver;
-    private subscriber;
-    private resolveInfoBase;
-    private returnContextAndResolveInfo;
-    static $$export: {
-        moduleName: string;
-        exportName: string;
-    };
-    isSyncAndSafe: boolean;
-    allowMultipleOptimizations: boolean;
-    private planDep;
-    private argsDep;
-    private contextDep;
-    private variableValuesDep;
-    private rootValueDep;
-    /** root fields can have null parent */
-    private isNotRoot;
-    constructor(resolver: (GraphQLFieldResolver<any, any> & {
-        displayName?: string;
-    }) | null | undefined, subscriber: (GraphQLFieldResolver<any, any> & {
-        displayName?: string;
-    }) | null | undefined, $plan: ExecutableStep, $args: ObjectStep, resolveInfoBase: ResolveInfoBase, returnContextAndResolveInfo?: boolean);
-    toStringMeta(): string | null;
-    deduplicate(peers: GraphQLResolverStep[]): GraphQLResolverStep[];
-    unbatchedExecute(_extra: ExecutionExtra, source: any, args: any, context: any, variableValues: any, rootValue: any): any;
-    unbatchedStream(_extra: ExecutionExtra, source: any, args: any, context: any, variableValues: any, rootValue: any): any;
-    stream(count: number, values: ReadonlyArray<GrafastValuesList<any>>, extra: ExecutionExtra): Promise<GrafastResultStreamList<any>>;
-}
-/** @internal */
-export declare class GraphQLItemHandler extends ExecutableStep implements PolymorphicStep {
-    static $$export: {
-        moduleName: string;
-        exportName: string;
-    };
-    private abstractType?;
-    private nullableInnerType;
-    isSyncAndSafe: boolean;
-    constructor($parent: ExecutableStep, nullableType: GraphQLNullableType & GraphQLOutputType);
-    planForType(): this;
-    listItem($item: __ItemStep<any>): GraphQLItemHandler;
-    /**
-     * Akin to graphql-js' completeAbstractValue... but just the typeName
-     * resolution part.
-     */
-    private figureOutTheTypeOf;
-    private actuallyWrapData;
-    private polymorphicWrapData;
-    wrapListData(data: unknown, context: unknown, resolveInfo: GraphQLResolveInfo): ({
-        data: {};
-        context: unknown;
-        resolveInfo: GraphQLResolveInfo;
-    } | null | undefined)[] | null;
-    execute(_count: number, values: [GrafastValuesList<any>]): GrafastResultsList<any>;
-}
-export declare function graphqlItemHandler($item: ExecutableStep, nullableType: GraphQLNullableType & GraphQLOutputType): GraphQLItemHandler;
-/**
- * Emulates what GraphQL does when calling a resolver, including handling of
- * polymorphism.
- *
- * @internal
- */
-export declare function graphqlResolver(resolver: GraphQLFieldResolver<any, any> | null | undefined, subscriber: GraphQLFieldResolver<any, any> | null | undefined, $step: ExecutableStep, $args: ObjectStep, resolveInfoBase: ResolveInfoBase): ExecutableStep;
-export {};
+import type { GraphQLNullableType, GraphQLOutputType } from "graphql";
+import { Step } from "../step.js";
+export declare function graphqlItemHandler($item: Step, nullableType: GraphQLNullableType & GraphQLOutputType): GraphQLItemHandler;
 //# sourceMappingURL=graphqlResolver.d.ts.map

package/dist/steps/graphqlResolver.js

@@ -1,18 +1,37 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.graphqlResolver = exports.graphqlItemHandler = exports.GraphQLItemHandler = exports.GraphQLResolverStep = void 0;
+exports.GraphQLItemHandler = exports.GraphQLResolverStep = void 0;
+exports.graphqlItemHandler = graphqlItemHandler;
+exports.graphqlResolver = graphqlResolver;
 const tslib_1 = require("tslib");
 const graphql = tslib_1.__importStar(require("graphql"));
+const iterall_1 = require("iterall");
 const index_js_1 = require("../index.js");
 const polymorphic_js_1 = require("../polymorphic.js");
 const step_js_1 = require("../step.js");
 const utils_js_1 = require("../utils.js");
-const { defaultTypeResolver, getNamedType, getNullableType, isAbstractType, isListType, } = graphql;
+const { defaultTypeResolver, getNamedType, getNullableType, isAbstractType, isListType, isNonNullType, } = graphql;
 function dcr(data, // but not a promise
 context, resolveInfo) {
     if (data == null) {
         return data;
     }
+    else if (data instanceof Error) {
+        return (0, index_js_1.flagError)(data);
+    }
+    else if ((0, utils_js_1.isPromiseLike)(data)) {
+        return data.then((data) => dcr(data, context, resolveInfo));
+    }
+    if ((0, iterall_1.isIterable)(data)) {
+        const list = Array.isArray(data) ? data : [...data];
+        if (list.some(utils_js_1.isPromiseLike)) {
+            const resolved = Promise.all(list.map((entry) => (0, utils_js_1.isPromiseLike)(entry) ? entry.then(null, index_js_1.flagError) : entry));
+            // TODO: this does recursion which is inefficient and also incorrect. We
+            // should only traverse as deep as the GraphQL type has lists.
+            return dcr(resolved, context, resolveInfo);
+        }
+    }
+    // TODO: support async iterables
     return { data, context, resolveInfo };
 }
 /**
@@ -21,7 +40,7 @@ context, resolveInfo) {
  *
  * @internal
  */
-class GraphQLResolverStep extends step_js_1.UnbatchedExecutableStep {
+class GraphQLResolverStep extends step_js_1.UnbatchedStep {
     static { this.$$export = {
         moduleName: "grafast",
         exportName: "GraphQLResolverStep",
@@ -52,75 +71,54 @@ class GraphQLResolverStep extends step_js_1.UnbatchedExecutableStep {
             this.subscriber?.name ||
             null);
     }
-    deduplicate(peers) {
-        return peers.filter((peer) => peer.resolver === this.resolver && peer.subscriber === this.subscriber);
-    }
-    unbatchedExecute(_extra, source, args, context, variableValues, rootValue) {
-        if (this.isNotRoot && source == null) {
-            return source;
-        }
-        const resolveInfo = Object.assign(Object.create(this.resolveInfoBase), {
-            variableValues,
-            rootValue,
-            path: {
-                typename: this.resolveInfoBase.parentType.name,
-                key: this.resolveInfoBase.fieldName,
-                // ENHANCE: add full support for path (requires runtime indexes)
-                prev: undefined,
-            },
-        });
-        const data = this.resolver?.(source, args, context, resolveInfo);
-        if (this.returnContextAndResolveInfo) {
-            if ((0, utils_js_1.isPromiseLike)(data)) {
-                return data.then((data) => dcr(data, context, resolveInfo));
+    unbatchedExecute(extra, source, args, context, variableValues, rootValue) {
+        if (!extra.stream) {
+            if (this.isNotRoot && source == null) {
+                return source;
             }
-            else {
+            const resolveInfo = Object.assign(Object.create(this.resolveInfoBase), {
+                variableValues,
+                rootValue,
+                path: {
+                    typename: this.resolveInfoBase.parentType.name,
+                    key: this.resolveInfoBase.fieldName,
+                    // ENHANCE: add full support for path (requires runtime indexes)
+                    prev: undefined,
+                },
+            });
+            const data = this.resolver?.(source, args, context, resolveInfo);
+            if (this.returnContextAndResolveInfo) {
                 return dcr(data, context, resolveInfo);
             }
+            else {
+                return flagErrorIfErrorAsync(data);
+            }
         }
         else {
-            return data;
-        }
-    }
-    unbatchedStream(_extra, source, args, context, variableValues, rootValue) {
-        if (this.isNotRoot) {
-            return Promise.reject(new Error(`Invalid non-root subscribe`));
-        }
-        if (this.subscriber == null) {
-            return Promise.reject(new Error(`Cannot subscribe to field`));
-        }
-        if (this.returnContextAndResolveInfo) {
-            return Promise.reject(new Error(`Subscription with returnContextAndResolveInfo is not supported`));
-        }
-        const resolveInfo = Object.assign(Object.create(this.resolveInfoBase), {
-            // ENHANCE: add support for path
-            variableValues,
-            rootValue,
-        });
-        const data = this.subscriber(source, args, context, resolveInfo);
-        return data;
-    }
-    async stream(count, values, extra) {
-        const results = [];
-        const depCount = this.dependencies.length;
-        for (let i = 0; i < count; i++) {
-            try {
-                const tuple = [];
-                for (let j = 0; j < depCount; j++) {
-                    tuple[j] = values[j][i];
-                }
-                results[i] = this.unbatchedStream(extra, ...tuple);
+            if (this.isNotRoot) {
+                return Promise.reject(new Error(`Invalid non-root subscribe`));
+            }
+            if (this.subscriber == null) {
+                return Promise.reject(new Error(`Cannot subscribe to field`));
             }
-            catch (e) {
-                results[i] = e instanceof Error ? e : Promise.reject(e);
+            if (this.returnContextAndResolveInfo) {
+                return Promise.reject(new Error(`Subscription with returnContextAndResolveInfo is not supported`));
             }
+            const resolveInfo = Object.assign(Object.create(this.resolveInfoBase), {
+                // ENHANCE: add support for path
+                variableValues,
+                rootValue,
+            });
+            // TODO: we also need to call the resolver on each result?
+            const data = this.subscriber(source, args, context, resolveInfo);
+            // TODO: should apply flagErrorIfError to each value data yields
+            return flagErrorIfErrorAsync(data);
         }
-        return results;
     }
 }
 exports.GraphQLResolverStep = GraphQLResolverStep;
 /** @internal */
-class GraphQLItemHandler extends step_js_1.ExecutableStep {
+class GraphQLItemHandler extends step_js_1.Step {
     static { this.$$export = {
         moduleName: "grafast",
         exportName: "GraphQLItemHandler",
@@ -131,7 +129,13 @@ class GraphQLItemHandler extends step_js_1.ExecutableStep {
         this.isSyncAndSafe = false;
         this.addDependency($parent);
         if (isListType(nullableType)) {
-            this.nullableInnerType = nullableType.ofType;
+            const innerType = nullableType.ofType;
+            if (isNonNullType(innerType)) {
+                this.nullableInnerType = innerType.ofType;
+            }
+            else {
+                this.nullableInnerType = innerType;
+            }
         }
         else {
             if (!isAbstractType(nullableType)) {
@@ -196,13 +200,14 @@ class GraphQLItemHandler extends step_js_1.ExecutableStep {
         }
         return data.map((data) => dcr(data, context, resolveInfo));
     }
-    execute(_count, values) {
+    execute({ indexMap, values: [values0], }) {
         if (this.abstractType !== undefined) {
-            return values[0].map((data) => {
+            return indexMap((i) => {
+                const data = values0.at(i);
                 if (data == null) {
                     return data;
                 }
-                if ((0, utils_js_1.isPromiseLike)(data.data)) {
+                else if ((0, utils_js_1.isPromiseLike)(data.data)) {
                     return data.data.then((resolvedData) => this.polymorphicWrapData(resolvedData, data.context, data.resolveInfo));
                 }
                 else {
@@ -211,16 +216,19 @@ class GraphQLItemHandler extends step_js_1.ExecutableStep {
             });
         }
         else if (this.nullableInnerType != null) {
-            return values[0].map((d) => {
+            return indexMap((i) => {
+                const d = values0.at(i);
                 if (d == null) {
                     return null;
                 }
-                const { data, context, resolveInfo } = d;
-                if ((0, utils_js_1.isPromiseLike)(data)) {
-                    return data.then((data) => this.wrapListData(data, context, resolveInfo));
-                }
                 else {
-                    return this.wrapListData(data, context, resolveInfo);
+                    const { data, context, resolveInfo } = d;
+                    if ((0, utils_js_1.isPromiseLike)(data)) {
+                        return data.then((data) => this.wrapListData(data, context, resolveInfo));
+                    }
+                    else {
+                        return this.wrapListData(data, context, resolveInfo);
+                    }
                 }
             });
         }
@@ -233,7 +241,6 @@ exports.GraphQLItemHandler = GraphQLItemHandler;
 function graphqlItemHandler($item, nullableType) {
     return new GraphQLItemHandler($item, nullableType);
 }
-exports.graphqlItemHandler = graphqlItemHandler;
 /**
  * Emulates what GraphQL does when calling a resolver, including handling of
  * polymorphism.
@@ -256,5 +263,15 @@ function graphqlResolver(resolver, subscriber, $step, $args, resolveInfoBase) {
         return $resolverResult;
     }
 }
-exports.graphqlResolver = graphqlResolver;
+function flagErrorIfError(data) {
+    return data instanceof Error ? (0, index_js_1.flagError)(data) : data;
+}
+function flagErrorIfErrorAsync(data) {
+    if ((0, utils_js_1.isPromiseLike)(data)) {
+        return data.then(flagErrorIfError);
+    }
+    else {
+        return flagErrorIfError(data);
+    }
+}
 //# sourceMappingURL=graphqlResolver.js.map

package/dist/steps/groupBy.d.ts

@@ -1,4 +1,5 @@
-import type { ExecutableStep } from "../step.js";
+import type { Step } from "../step.js";
+import type { ConnectionCapableStep, ItemsStep } from "./connection.js";
 import type { __ListTransformStep, ListTransformItemPlanCallback } from "./listTransform.js";
 export type GroupByPlanMemo = Map<unknown, unknown[]>;
 /**
@@ -7,5 +8,5 @@ export type GroupByPlanMemo = Map<unknown, unknown[]>;
  * keys and the values are lists of the original entries that match these
  * grouping keys.
  */
-export declare function groupBy<TListStep extends ExecutableStep<readonly any[]>, TItemStep extends ExecutableStep<number>>(listStep: TListStep, mapper: ListTransformItemPlanCallback<TListStep, TItemStep>): __ListTransformStep<TListStep, TItemStep, GroupByPlanMemo, any>;
+export declare function groupBy<TListStep extends Step<readonly any[]> | ConnectionCapableStep<any, any>, TItemStep extends Step<number>>(listStep: TListStep, mapper: ListTransformItemPlanCallback<ItemsStep<TListStep>, TItemStep>): __ListTransformStep<TListStep, TItemStep, GroupByPlanMemo, any>;
 //# sourceMappingURL=groupBy.d.ts.map

package/dist/steps/groupBy.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.groupBy = void 0;
+exports.groupBy = groupBy;
 const tslib_1 = require("tslib");
 const chalk_1 = tslib_1.__importDefault(require("chalk"));
 const step_js_1 = require("../step.js");
@@ -36,5 +36,4 @@ function groupBy(listStep, mapper) {
         meta: `groupBy:${chalk_1.default.yellow(listStep.id)}${mapper.name ? `/${mapper.name}` : ""}`,
     });
 }
-exports.groupBy = groupBy;
 //# sourceMappingURL=groupBy.js.map

package/dist/steps/index.d.ts

@@ -1,12 +1,16 @@
-import type { OperationPlan } from "../index.js";
+import type { __TrackedValueStep, OperationPlan } from "../index.js";
 import type { __ValueStep } from "./__value.js";
 export declare function operationPlan(): OperationPlan;
 export declare function context<TContext extends Grafast.Context = Grafast.Context>(): __ValueStep<TContext>;
+export declare function rootValue(): __ValueStep<Record<string, any>>;
+export declare function trackedContext<TContext extends Grafast.Context = Grafast.Context>(): __TrackedValueStep<TContext>;
+export declare function trackedRootValue(): __TrackedValueStep<Record<string, any>>;
 /**
  * Turns on debug mode, calls the callback, and then turns debug mode back off
  * again.
  */
 export declare function debugPlans<T>(callback: () => T): T;
+export { __FlagStep, assertNotNull, inhibitOnNull, trap, TRAP_ERROR, TRAP_ERROR_OR_INHIBITED, TRAP_INHIBITED, } from "./__flag.js";
 export { access, AccessStep } from "./access.js";
 export { assertEdgeCapableStep, assertPageInfoCapableStep, connection, ConnectionCapableStep, ConnectionStep, EdgeCapableStep, EdgeStep, PageInfoCapableStep, } from "./connection.js";
 export { constant, ConstantStep } from "./constant.js";
@@ -20,20 +24,25 @@ export { last, LastStep } from "./last.js";
 export { list, ListStep } from "./list.js";
 export { listen, ListenStep } from "./listen.js";
 export { __ListTransformStep, listTransform, ListTransformItemPlanCallback, ListTransformOptions, ListTransformReduce, } from "./listTransform.js";
-export { makeDecodeNodeId, node, NodeStep, specFromNodeId } from "./node.js";
+export { makeDecodeNodeId, makeDecodeNodeIdRuntime, node, nodeIdFromNode, NodeStep, specFromNodeId, } from "./node.js";
 export { object, ObjectPlanMeta, ObjectStep } from "./object.js";
 export { partitionByIndex } from "./partitionByIndex.js";
 export { ActualKeyByDesiredKey, remapKeys, RemapKeysStep, } from "./remapKeys.js";
 export { reverse, reverseArray, ReverseStep } from "./reverse.js";
-export { setter, SetterCapableStep, SetterStep } from "./setter.js";
+export { createObjectAndApplyChildren, Setter, setter, SetterCapable, } from "./setter.js";
+export { sideEffect, SideEffectStep } from "./sideEffect.js";
 export { __InputListStep } from "./__inputList.js";
 export { __InputObjectStep, __InputObjectStepWithDollars, } from "./__inputObject.js";
 export { __InputStaticLeafStep } from "./__inputStaticLeaf.js";
 export { __ItemStep } from "./__item.js";
 export { __TrackedValueStep, __TrackedValueStepWithDollars, } from "./__trackedValue.js";
 export { __ValueStep } from "./__value.js";
+export { applyInput, ApplyInputStep, assertModifier, isModifier, Modifier, } from "./applyInput.js";
 export { applyTransforms, ApplyTransformsStep } from "./applyTransforms.js";
+export { bakedInput, bakedInputRuntime, BakedInputStep } from "./bakedInput.js";
+export { condition, ConditionStep } from "./condition.js";
 export { GraphQLItemHandler, graphqlItemHandler, graphqlResolver, GraphQLResolverStep, } from "./graphqlResolver.js";
 export { LoadedRecordStep, loadMany, LoadManyCallback, loadManyCallback, loadOne, LoadOneCallback, loadOneCallback, LoadOptions, LoadStep, } from "./load.js";
+export { polymorphicBranch, PolymorphicBranchMatcher, PolymorphicBranchMatchers, PolymorphicBranchStep, } from "./polymorphicBranch.js";
 export { proxy, ProxyStep } from "./proxy.js";
 //# sourceMappingURL=index.d.ts.map