grafast 0.0.1-alpha.2 → 0.0.1-alpha.4

package/dist/input.d.ts

@@ -1,4 +1,4 @@
-import type { GraphQLInputType, GraphQLType, ListTypeNode, NamedTypeNode, NonNullTypeNode, ValueNode } from "graphql";
+import type { ConstValueNode, GraphQLInputType, GraphQLType, ListTypeNode, NamedTypeNode, NonNullTypeNode, ValueNode } from "graphql";
 import type { OperationPlan } from "./engine/OperationPlan.js";
 import { __InputDynamicScalarStep } from "./steps/__inputDynamicScalar.js";
 import { __InputObjectStep } from "./steps/__inputObject.js";
@@ -7,5 +7,5 @@ import { __InputListStep, __InputStaticLeafStep, __TrackedValueStep } from "./st
 export type InputStep = __TrackedValueStep | __InputListStep | __InputStaticLeafStep | __InputDynamicScalarStep | __InputObjectStep | ConstantStep<undefined>;
 export declare function assertInputStep(itemPlan: unknown): asserts itemPlan is InputStep;
 export declare function graphqlGetTypeForNode(operationPlan: OperationPlan, node: NamedTypeNode | ListTypeNode | NonNullTypeNode): GraphQLType;
-export declare function inputPlan(operationPlan: OperationPlan, inputType: GraphQLInputType, seenTypes: Set<GraphQLInputType>, rawInputValue: ValueNode | undefined, defaultValue?: ValueNode | undefined): InputStep;
+export declare function inputPlan(operationPlan: OperationPlan, inputType: GraphQLInputType, rawInputValue: ValueNode | undefined, defaultValue?: ConstValueNode | undefined, inSeenTypes?: ReadonlyArray<GraphQLInputType>): InputStep;
 //# sourceMappingURL=input.d.ts.map

package/dist/interfaces.d.ts

@@ -1,14 +1,19 @@
 import type EventEmitter from "eventemitter3";
 import type { PluginHook } from "graphile-config";
-import type { ASTNode, ExecutionArgs, GraphQLArgument, GraphQLArgumentConfig, GraphQLField, GraphQLFieldConfig, GraphQLInputField, GraphQLInputFieldConfig, GraphQLInputObjectType, GraphQLInputType, GraphQLList, GraphQLNonNull, GraphQLOutputType, GraphQLScalarType, GraphQLSchema, GraphQLType } from "graphql";
+import type { ASTNode, ExecutionArgs, GraphQLArgument, GraphQLArgumentConfig, GraphQLField, GraphQLFieldConfig, GraphQLInputField, GraphQLInputFieldConfig, GraphQLInputObjectType, GraphQLInputType, GraphQLList, GraphQLNonNull, GraphQLOutputType, GraphQLScalarType, GraphQLSchema, GraphQLType, ValueNode, VariableNode } from "graphql";
 import type { Bucket, RequestTools } from "./bucket.js";
 import type { InputStep } from "./input.js";
 import type { ExecutableStep, ListCapableStep, ModifierStep } from "./step.js";
 import type { GrafastInputObjectType, GrafastObjectType } from "./utils.js";
 type PromiseOrValue<T> = T | Promise<T>;
+export interface GrafastTimeouts {
+    planning?: number;
+    execution?: number;
+}
 export interface GrafastOptions {
     context?: Record<string, any> | (<TContext extends Record<string, any>>(ctx: Partial<Grafast.RequestContext>, currentContext?: Partial<TContext>) => PromiseOrValue<Partial<TContext>>);
     explain?: boolean | string[];
+    timeouts?: GrafastTimeouts;
 }
 declare global {
     namespace Grafast {
@@ -105,6 +110,9 @@ export declare const $$eventEmitter: unique symbol;
 export declare const $$streamMore: unique symbol;
 export declare const $$proxy: unique symbol;
 export declare const $$safeError: unique symbol;
+export declare const $$subroutine: unique symbol;
+export declare const $$timeout: unique symbol;
+export declare const $$ts: unique symbol;
 export interface PolymorphicData<TType extends string = string, TData = any> {
     [$$concreteType]: TType;
     [$$data]?: TData;
@@ -199,6 +207,7 @@ export interface StepOptions {
 }
 export interface StepOptimizeOptions {
     stream: StepStreamOptions | null;
+    meta: Record<string, unknown> | undefined;
 }
 export type GrafastSubscriber<TTopics extends {
     [key: string]: any;
@@ -245,7 +254,8 @@ export type ExecutionEventMap = {
 };
 export type ExecutionEventEmitter = TypedEventEmitter<ExecutionEventMap>;
 export interface ExecutionExtra {
-    meta: Record<string, unknown>;
+    stopTime: number | null;
+    meta: Record<string, unknown> | undefined;
     eventEmitter: ExecutionEventEmitter | undefined;
     _bucket: Bucket;
     _requestContext: RequestTools;
@@ -266,5 +276,6 @@ export type UnwrapPlanTuple<TIn extends readonly ExecutableStep[]> = {
 } & {
     length: number;
 };
+export type NotVariableValueNode = Exclude<ValueNode, VariableNode>;
 export {};
 //# sourceMappingURL=interfaces.d.ts.map

package/dist/prepare.d.ts

@@ -1,13 +1,14 @@
 import type { ExecutionArgs } from "graphql";
 import type { AsyncExecutionResult, ExecutionResult } from "graphql/execution/execute";
 import type { OperationPlan } from "./index.js";
-import type { PromiseOrDirect } from "./interfaces.js";
+import type { GrafastTimeouts, PromiseOrDirect } from "./interfaces.js";
 declare const $$contextPlanCache: unique symbol;
 export interface GrafastPrepareOptions {
     explain?: boolean | string[];
     outputDataAsString?: boolean;
+    timeouts?: GrafastTimeouts;
 }
-export declare function executePreemptive(operationPlan: OperationPlan, variableValues: any, context: any, rootValue: any, outputDataAsString: boolean): PromiseOrDirect<ExecutionResult | AsyncGenerator<AsyncExecutionResult, void, void>>;
+export declare function executePreemptive(operationPlan: OperationPlan, variableValues: any, context: any, rootValue: any, outputDataAsString: boolean, executionTimeout: number | null): PromiseOrDirect<ExecutionResult | AsyncGenerator<AsyncExecutionResult, void, void>>;
 declare module "./engine/OperationPlan.js" {
     interface OperationPlan {
         [$$contextPlanCache]?: string;

package/dist/step.d.ts

@@ -1,7 +1,8 @@
 import type { GraphQLObjectType } from "graphql";
-import type { LayerPlan } from "./engine/LayerPlan.js";
+import type { LayerPlan, LayerPlanReasonSubroutine } from "./engine/LayerPlan.js";
 import type { OperationPlan } from "./engine/OperationPlan.js";
 import type { ExecutionExtra, GrafastResultsList, GrafastResultStreamList, GrafastValuesList, PromiseOrDirect, StepOptimizeOptions, StepOptions } from "./interfaces.js";
+import { $$subroutine } from "./interfaces.js";
 import type { __ItemStep } from "./steps/index.js";
 export declare const $$deepDepSkip: unique symbol;
 export declare const $$noExec: unique symbol;
@@ -10,6 +11,7 @@ export declare const assertFinalized: typeof reallyAssertFinalized;
 export declare abstract class BaseStep {
     readonly layerPlan: LayerPlan;
     readonly operationPlan: OperationPlan;
+    [$$subroutine]: LayerPlan<LayerPlanReasonSubroutine> | null;
     isArgumentsFinalized: boolean;
     isFinalized: boolean;
     debug: boolean;
@@ -32,9 +34,10 @@ export declare class ExecutableStep<TData = any> extends BaseStep {
     isOptimized: boolean;
     allowMultipleOptimizations: boolean;
     _stepOptions: StepOptions;
-    polymorphicPaths: ReadonlySet<string>;
+    polymorphicPaths: ReadonlySet<string> | null;
     store: boolean;
-    metaKey: number | string | symbol;
+    metaKey: number | string | symbol | undefined;
+    optimizeMetaKey: number | string | symbol | undefined;
     constructor();
     protected withMyLayerPlan<T>(callback: () => T): T;
     protected getStep(id: number): ExecutableStep;
@@ -42,9 +45,9 @@ export declare class ExecutableStep<TData = any> extends BaseStep {
     protected getDepDeep(depId: number): ExecutableStep;
     toString(): string;
     protected addDependency(step: ExecutableStep, skipDeduplication?: boolean): number;
-    deduplicate(_peers: readonly ExecutableStep[]): readonly ExecutableStep[];
-    deduplicatedWith(replacement: ExecutableStep): void;
-    optimize(_options: StepOptimizeOptions): ExecutableStep;
+    deduplicate?(_peers: readonly ExecutableStep[]): readonly ExecutableStep[];
+    deduplicatedWith?(replacement: ExecutableStep): void;
+    optimize?(_options: StepOptimizeOptions): ExecutableStep;
     finalize(): void;
     execute(count: number, values: ReadonlyArray<GrafastValuesList<any>>, extra: ExecutionExtra): PromiseOrDirect<GrafastResultsList<TData>>;
     destroy(): void;

package/dist/steps/__inputDynamicScalar.d.ts

@@ -11,7 +11,7 @@ export declare class __InputDynamicScalarStep<TLeaf = any> extends UnbatchedExec
     private variableNames;
     constructor(inputType: GraphQLScalarType, value: ListValueNode | ObjectValueNode);
     valueFromValues(variableValues: any[]): any;
-    unbatchedExecute: (extra: ExecutionExtra, ...variableValues: any[]) => TLeaf;
+    unbatchedExecute: (_extra: ExecutionExtra, ...variableValues: any[]) => TLeaf;
     eval(): TLeaf;
     evalIs(expectedValue: undefined | null | 0): boolean;
 }

package/dist/steps/__inputList.d.ts

@@ -1,6 +1,7 @@
-import type { GraphQLInputType, ValueNode } from "graphql";
-import { GraphQLList } from "graphql";
+import type { GraphQLInputType } from "graphql";
+import * as graphql from "graphql";
 import type { InputStep } from "../input.js";
+import type { NotVariableValueNode } from "../interfaces.js";
 import { ExecutableStep } from "../step.js";
 import type { ConstantStep } from "./constant.js";
 export declare class __InputListStep extends ExecutableStep {
@@ -11,8 +12,8 @@ export declare class __InputListStep extends ExecutableStep {
     };
     isSyncAndSafe: boolean;
     private itemCount;
-    constructor(inputType: GraphQLList<GraphQLInputType>, seenTypes: Set<GraphQLInputType>, inputValues: ValueNode | undefined);
-    optimize(): ConstantStep<null> | ConstantStep<any[]>;
+    constructor(inputType: graphql.GraphQLList<GraphQLInputType>, seenTypes: ReadonlyArray<GraphQLInputType> | undefined, inputValues: NotVariableValueNode | undefined);
+    optimize(): ExecutableStep;
     execute(): any[];
     unbatchedExecute: () => any;
     at(index: number): InputStep | ConstantStep<undefined>;

package/dist/steps/__inputObject.d.ts

@@ -1,6 +1,6 @@
-import type { GraphQLInputObjectType, GraphQLInputType, ValueNode } from "graphql";
+import type { GraphQLInputObjectType, GraphQLInputType } from "graphql";
 import type { InputStep } from "../input.js";
-import type { ExecutionExtra } from "../interfaces.js";
+import type { ExecutionExtra, NotVariableValueNode } from "../interfaces.js";
 import { UnbatchedExecutableStep } from "../step.js";
 export declare class __InputObjectStep extends UnbatchedExecutableStep {
     private inputObjectType;
@@ -11,10 +11,10 @@ export declare class __InputObjectStep extends UnbatchedExecutableStep {
     };
     isSyncAndSafe: boolean;
     private inputFields;
-    constructor(inputObjectType: GraphQLInputObjectType, seenTypes: Set<GraphQLInputType>, inputValues: ValueNode | undefined);
+    constructor(inputObjectType: GraphQLInputObjectType, seenTypes: ReadonlyArray<GraphQLInputType>, inputValues: NotVariableValueNode | undefined);
     optimize(): this | import("./constant.js").ConstantStep<null>;
     finalize(): void;
-    unbatchedExecute(extra: ExecutionExtra, ...values: any[]): any;
+    unbatchedExecute(_extra: ExecutionExtra, ...values: any[]): any;
     get(attrName: string): InputStep;
     eval(): any;
     evalIs(value: null | undefined | 0): boolean;

package/dist/steps/__inputStaticLeaf.d.ts

@@ -1,4 +1,4 @@
-import type { GraphQLLeafType, ValueNode } from "graphql";
+import type { BooleanValueNode, EnumValueNode, FloatValueNode, GraphQLLeafType, IntValueNode, NullValueNode, StringValueNode } from "graphql";
 import { UnbatchedExecutableStep } from "../step.js";
 export declare class __InputStaticLeafStep<TLeaf = any> extends UnbatchedExecutableStep<TLeaf> {
     static $$export: {
@@ -7,8 +7,9 @@ export declare class __InputStaticLeafStep<TLeaf = any> extends UnbatchedExecuta
     };
     isSyncAndSafe: boolean;
     private readonly coercedValue;
-    constructor(inputType: GraphQLLeafType, value: ValueNode | undefined);
+    constructor(inputType: GraphQLLeafType, value: IntValueNode | FloatValueNode | StringValueNode | BooleanValueNode | NullValueNode | EnumValueNode | undefined);
     unbatchedExecute(): TLeaf;
+    optimize(): import("./constant.js").ConstantStep<any>;
     eval(): TLeaf;
     evalIs(expectedValue: unknown): boolean;
 }

package/dist/steps/__trackedValue.d.ts

@@ -14,7 +14,7 @@ export declare class __TrackedValueStep<TData = any> extends UnbatchedExecutable
     private readonly path;
     constructor(value: TData | undefined, valuePlan: __ValueStep<TData> | AccessStep<TData>, constraints: Constraint[], path?: Array<string | number>);
     execute(_count: number, values: [GrafastValuesList<TData>]): GrafastResultsList<TData>;
-    unbatchedExecute(extra: ExecutionExtra, v: TData): TData;
+    unbatchedExecute(_extra: ExecutionExtra, v: TData): TData;
     private getValuePlan;
     get<TAttribute extends keyof TData & string>(attrName: TAttribute): __TrackedValueStep<TData[TAttribute]>;
     at<TIndex extends keyof TData & number>(index: TIndex): __TrackedValueStep<TData[TIndex]>;

package/dist/steps/access.d.ts

@@ -16,7 +16,6 @@ export declare class AccessStep<TData> extends UnbatchedExecutableStep<TData> {
     get<TAttr extends keyof TData>(attrName: TAttr): AccessStep<TData[TAttr]>;
     at<TIndex extends keyof TData>(index: TIndex): AccessStep<TData[TIndex]>;
     optimize(): AccessStep<TData>;
-    finalize(): void;
     unbatchedExecute(_extra: ExecutionExtra, ..._values: any[]): any;
     deduplicate(peers: AccessStep<unknown>[]): AccessStep<TData>[];
 }

package/dist/steps/connection.d.ts

@@ -48,7 +48,7 @@ export declare class ConnectionStep<TItemStep extends ExecutableStep, TCursorSte
     getSubplan(): TStep;
     cloneSubplanWithoutPagination(...args: ParametersExceptFirst<TStep["connectionClone"]>): TStep;
     cloneSubplanWithPagination(...args: ParametersExceptFirst<TStep["connectionClone"]> | []): TStep;
-    edges(): TStep | import("./listTransform.js").__ListTransformStep<any, any, any, any>;
+    edges(): ExecutableStep;
     nodes(): TStep | import("./listTransform.js").__ListTransformStep<any, any, any, any>;
     wrapEdge($edge: TItemStep): EdgeStep<TItemStep, TCursorStep, TStep, TNodeStep>;
     pageInfo(): PageInfoCapableStep;
@@ -77,7 +77,7 @@ export declare class EdgeStep<TItemStep extends ExecutableStep, TCursorStep exte
     optimize(): EdgeStep<TItemStep, TCursorStep, TStep, TNodeStep>;
     deduplicate(_peers: EdgeStep<any, any, any, any>[]): EdgeStep<TItemStep, TCursorStep, TStep, TNodeStep>[];
     deduplicatedWith(replacement: EdgeStep<any, any, any, any>): void;
-    unbatchedExecute(extra: ExecutionExtra, record: any, cursor: any): any;
+    unbatchedExecute(_extra: ExecutionExtra, record: any, cursor: any): any;
 }
 export declare function connection<TItemStep extends ExecutableStep, TCursorStep extends ExecutableStep, TStep extends ConnectionCapableStep<TItemStep, TCursorStep>, TNodeStep extends ExecutableStep = ExecutableStep>(step: TStep, itemPlan?: ($item: TItemStep) => TNodeStep, cursorPlan?: ($item: TItemStep) => ExecutableStep<string | null>): ConnectionStep<TItemStep, TCursorStep, TStep, TNodeStep>;
 export {};

package/dist/steps/constant.d.ts

@@ -1,13 +1,15 @@
 import type { GrafastResultsList } from "../interfaces.js";
 import { UnbatchedExecutableStep } from "../step.js";
 export declare class ConstantStep<TData> extends UnbatchedExecutableStep<TData> {
-    private data;
+    readonly data: TData;
     static $$export: {
         moduleName: string;
         exportName: string;
     };
     isSyncAndSafe: boolean;
     constructor(data: TData);
+    toStringMeta(): string;
+    deduplicate(peers: readonly ConstantStep<any>[]): ConstantStep<any>[];
     execute(count: number): GrafastResultsList<TData>;
     eval(): TData;
     evalIs(value: any): boolean;

package/dist/steps/first.d.ts

@@ -10,7 +10,7 @@ export declare class FirstStep<TData> extends UnbatchedExecutableStep<TData> {
     allowMultipleOptimizations: boolean;
     constructor(parentPlan: ExecutableStep<ReadonlyArray<TData>>);
     execute(count: number, values: GrafastValuesList<[ReadonlyArray<TData>]>): GrafastResultsList<TData>;
-    unbatchedExecute(extra: ExecutionExtra, list: any[]): any;
+    unbatchedExecute(_extra: ExecutionExtra, list: any[]): any;
     deduplicate(peers: FirstStep<TData>[]): FirstStep<TData>[];
     optimize(): ExecutableStep<any> | this;
 }

package/dist/steps/graphqlResolver.d.ts

@@ -28,8 +28,8 @@ export declare class GraphQLResolverStep extends UnbatchedExecutableStep {
     }) | 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;
+    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>>;
 }
 export declare class GraphQLItemHandler extends ExecutableStep implements PolymorphicStep {

package/dist/steps/last.d.ts

@@ -9,7 +9,7 @@ export declare class LastStep<TData> extends UnbatchedExecutableStep<TData> {
     isSyncAndSafe: boolean;
     allowMultipleOptimizations: boolean;
     constructor(parentPlan: ExecutableStep<ReadonlyArray<TData>>);
-    unbatchedExecute: (extra: ExecutionExtra, list: ReadonlyArray<TData>) => TData;
+    unbatchedExecute: (_extra: ExecutionExtra, list: ReadonlyArray<TData>) => TData;
     deduplicate(peers: LastStep<TData>[]): LastStep<TData>[];
     optimize(): ExecutableStep<any> | this;
 }

package/dist/steps/list.d.ts

@@ -1,6 +1,7 @@
-import type { ExecutionExtra, UnwrapPlanTuple } from "../interfaces.js";
+import type { ExecutionExtra, StepOptimizeOptions, UnwrapPlanTuple } from "../interfaces.js";
 import type { ExecutableStep } from "../step.js";
 import { UnbatchedExecutableStep } from "../step.js";
+import { ConstantStep } from "./constant.js";
 export declare class ListStep<const TPlanTuple extends readonly ExecutableStep[]> extends UnbatchedExecutableStep<UnwrapPlanTuple<TPlanTuple>> {
     static $$export: {
         moduleName: string;
@@ -8,11 +9,13 @@ export declare class ListStep<const TPlanTuple extends readonly ExecutableStep[]
     };
     isSyncAndSafe: boolean;
     allowMultipleOptimizations: boolean;
+    optimizeMetaKey: string;
     constructor(list: TPlanTuple);
     toStringMeta(): string;
     execute(count: number, values: any[][]): Array<UnwrapPlanTuple<TPlanTuple>>;
-    unbatchedExecute(extra: ExecutionExtra, ...values: any[]): UnwrapPlanTuple<TPlanTuple>;
+    unbatchedExecute(_extra: ExecutionExtra, ...values: any[]): UnwrapPlanTuple<TPlanTuple>;
     deduplicate(peers: ListStep<TPlanTuple>[]): ListStep<TPlanTuple>[];
+    optimize(opts: StepOptimizeOptions): this | ConstantStep<any[]>;
     at<TIndex extends keyof TPlanTuple>(index: TIndex): TPlanTuple[TIndex];
 }
 export declare function list<const TPlanTuple extends readonly ExecutableStep[]>(list: TPlanTuple): ListStep<TPlanTuple>;

package/dist/steps/node.d.ts

@@ -18,7 +18,7 @@ export declare class NodeStep<TCodecs extends {
     }, $id: ExecutableStep<string>);
     planForType(type: GraphQLObjectType): ExecutableStep;
     private getTypeNameFromSpecifier;
-    unbatchedExecute: (extra: ExecutionExtra, specifier: any) => PolymorphicData<string, ReadonlyArray<any>> | null;
+    unbatchedExecute: (_extra: ExecutionExtra, specifier: any) => PolymorphicData<string, ReadonlyArray<any>> | null;
 }
 export declare function node<TCodecs extends {
     [key: string]: NodeIdCodec<any>;

package/dist/steps/object.d.ts

@@ -1,6 +1,7 @@
-import type { ExecutionExtra } from "../interfaces.js";
+import type { ExecutionExtra, StepOptimizeOptions } from "../interfaces.js";
 import type { ExecutableStep } from "../step.js";
 import { UnbatchedExecutableStep } from "../step.js";
+import { ConstantStep } from "./constant.js";
 import type { SetterCapableStep } from "./setter.js";
 type DataFromStep<TStep extends ExecutableStep> = TStep extends ExecutableStep<infer TData> ? TData : never;
 type DataFromPlans<TPlans extends {
@@ -31,15 +32,17 @@ export declare class ObjectStep<TPlans extends {
     isSyncAndSafe: boolean;
     allowMultipleOptimizations: boolean;
     private keys;
+    optimizeMetaKey: string;
     constructor(obj: TPlans);
     set<TKey extends keyof TPlans>(key: TKey, plan: TPlans[TKey]): void;
     getStepForKey<TKey extends keyof TPlans>(key: TKey, allowMissing?: boolean): TKey extends keyof TPlans ? TPlans[TKey] : null;
     toStringMeta(): string;
-    tupleToObjectJIT(): (extra: ExecutionExtra, ...tuple: Array<DataFromPlans<TPlans>[keyof TPlans]>) => DataFromPlans<TPlans>;
+    tupleToObjectJIT(callback: (fn: (extra: ExecutionExtra, ...tuple: Array<DataFromPlans<TPlans>[keyof TPlans]>) => DataFromPlans<TPlans>) => void): void;
     finalize(): void;
     execute(count: number, values: Array<Array<DataFromPlans<TPlans>[keyof TPlans]>>, extra: ExecutionExtra): Array<DataFromPlans<TPlans>>;
     unbatchedExecute(_extra: ExecutionExtra, ..._values: any[]): any;
     deduplicate(peers: ObjectStep<any>[]): ObjectStep<TPlans>[];
+    optimize(opts: StepOptimizeOptions): this | ConstantStep<any>;
     get<TKey extends keyof TPlans>(key: TKey): TPlans[TKey];
 }
 export declare function object<TPlans extends {

package/dist/steps/proxy.d.ts

@@ -14,7 +14,7 @@ export declare class ProxyStep<T> extends UnbatchedExecutableStep<T> {
     toStringMeta(): string | null;
     addDependency(step: ExecutableStep): number;
     execute(_count: number, values: [GrafastValuesList<T>]): GrafastResultsList<T>;
-    unbatchedExecute(extra: ExecutionExtra, value: T): T;
+    unbatchedExecute(_extra: ExecutionExtra, value: T): T;
     stream: undefined;
 }
 declare module "../step.js" {

package/dist/steps/remapKeys.d.ts

@@ -15,8 +15,10 @@ export declare class RemapKeysStep extends UnbatchedExecutableStep {
     private mapper;
     constructor($plan: ExecutableStep, actualKeyByDesiredKey: ActualKeyByDesiredKey);
     toStringMeta(): string;
+    optimize(): ExecutableStep<any> | this;
+    finalize(): void;
     execute(_count: number, values: GrafastValuesList<any[]>): GrafastResultsList<any>;
-    unbatchedExecute(extra: ExecutionExtra, value: any): any;
+    unbatchedExecute(_extra: ExecutionExtra, value: any): any;
     deduplicate(peers: RemapKeysStep[]): RemapKeysStep[];
 }
 export declare function remapKeys($step: ExecutableStep, actualKeyByDesiredKey: {

package/dist/steps/reverse.d.ts

@@ -11,7 +11,7 @@ export declare class ReverseStep<TData> extends UnbatchedExecutableStep<readonly
     allowMultipleOptimizations: boolean;
     constructor(plan: ExecutableStep<readonly TData[]>);
     execute(_count: number, values: [GrafastValuesList<TData[]>]): GrafastResultsList<TData[]>;
-    unbatchedExecute(extra: ExecutionExtra, arr: TData[]): TData[];
+    unbatchedExecute(_extra: ExecutionExtra, arr: TData[]): TData[];
     deduplicate(peers: ReverseStep<TData>[]): ReverseStep<TData>[];
 }
 export declare function reverse<TData>(plan: ExecutableStep<readonly TData[]>): ReverseStep<TData>;

package/dist/timeSource.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="node" />
+export declare const timeSource: import("perf_hooks").Performance | DateConstructor;
+//# sourceMappingURL=timeSource.d.ts.map

package/dist/utils.d.ts

@@ -1,5 +1,5 @@
-import type { FieldNode, GraphQLEnumValueConfig, GraphQLFieldConfig, GraphQLInputFieldConfig, GraphQLInputObjectTypeConfig, GraphQLInputType, GraphQLNamedType, GraphQLObjectTypeConfig, GraphQLOutputType, GraphQLSchema, ValueNode } from "graphql";
-import { GraphQLEnumType, GraphQLInputObjectType, GraphQLObjectType } from "graphql";
+import type { ConstValueNode, FieldNode, GraphQLEnumValueConfig, GraphQLFieldConfig, GraphQLInputFieldConfig, GraphQLInputObjectTypeConfig, GraphQLInputType, GraphQLNamedType, GraphQLObjectTypeConfig, GraphQLOutputType, GraphQLSchema } from "graphql";
+import * as graphql from "graphql";
 import type { Deferred } from "./deferred.js";
 import type { OperationPlan } from "./engine/OperationPlan.js";
 import type { InputStep } from "./input.js";
@@ -7,7 +7,7 @@ import type { BaseGraphQLArguments, GrafastFieldConfig, GrafastInputFieldConfig,
 import type { ExecutableStep, ModifierStep } from "./step.js";
 export declare const ROOT_VALUE_OBJECT: any;
 export declare function assertNullPrototype(object: Record<string, unknown>, description: string): void;
-export declare function defaultValueToValueNode(type: GraphQLInputType, defaultValue: unknown): ValueNode | undefined;
+export declare function defaultValueToValueNode(type: GraphQLInputType, defaultValue: unknown): ConstValueNode | undefined;
 export declare function isPromise<T>(t: T | Promise<T>): t is Promise<T>;
 export declare function isPromiseLike<T>(t: T | Promise<T> | PromiseLike<T>): t is PromiseLike<T>;
 export declare function isDeferred<T>(t: T | Promise<T> | Deferred<T>): t is Deferred<T>;
@@ -21,7 +21,7 @@ export type ObjectTypeSpec<TContext extends Grafast.Context, TParentStep extends
 export declare function objectSpec<TContext extends Grafast.Context, TParentStep extends ExecutableStep, TFields extends ObjectTypeFields<TContext, TParentStep>>(spec: ObjectTypeSpec<TContext, TParentStep, TFields>, Step: ((step: ExecutableStep) => asserts step is ExecutableStep) | {
     new (...args: any[]): TParentStep;
 } | null): GraphQLObjectTypeConfig<any, TContext>;
-export type GrafastObjectType<TContext extends Grafast.Context, TParentStep extends ExecutableStep, TFields extends ObjectTypeFields<TContext, TParentStep>> = GraphQLObjectType<TParentStep extends ExecutableStep<infer U> ? U : never, TContext> & {
+export type GrafastObjectType<TContext extends Grafast.Context, TParentStep extends ExecutableStep, TFields extends ObjectTypeFields<TContext, TParentStep>> = graphql.GraphQLObjectType<TParentStep extends ExecutableStep<infer U> ? U : never, TContext> & {
     TParentStep: TParentStep;
     TFields: TFields;
 };
@@ -36,7 +36,7 @@ export type GrafastInputFieldConfigMap<TContext extends Grafast.Context, TParent
 export type InputObjectTypeSpec<TContext extends Grafast.Context, TParentStep extends ModifierStep<any>, TFields extends GrafastInputFieldConfigMap<TContext, TParentStep>> = Omit<GraphQLInputObjectTypeConfig, "fields"> & {
     fields: TFields | (() => TFields);
 };
-export type GrafastInputObjectType<TContext extends Grafast.Context, TParentStep extends ModifierStep<any>, TFields extends GrafastInputFieldConfigMap<TContext, TParentStep>> = GraphQLInputObjectType & {
+export type GrafastInputObjectType<TContext extends Grafast.Context, TParentStep extends ModifierStep<any>, TFields extends GrafastInputFieldConfigMap<TContext, TParentStep>> = graphql.GraphQLInputObjectType & {
     TContext: TContext;
     TParentStep: TParentStep;
     TFields: TFields;
@@ -49,7 +49,7 @@ declare module "graphql" {
     }
 }
 declare const $$valueConfigByValue: unique symbol;
-export declare function getEnumValueConfig(enumType: GraphQLEnumType, outputValue: string): GraphQLEnumValueConfig | undefined;
+export declare function getEnumValueConfig(enumType: graphql.GraphQLEnumType, outputValue: string): GraphQLEnumValueConfig | undefined;
 export declare const sharedNull: any;
 export declare function stack(message: string, length?: number): void;
 export declare function arrayOfLength(length: number, fill?: any): any[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grafast",
-  "version": "0.0.1-alpha.2",
+  "version": "0.0.1-alpha.4",
   "description": "Cutting edge GraphQL planning and execution engine",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -45,13 +45,13 @@
     "node": ">=14.17"
   },
   "dependencies": {
-    "@graphile/lru": "^5.0.0-alpha.1",
+    "@graphile/lru": "^5.0.0-alpha.2",
     "debug": "^4.3.3",
-    "tamedevil": "^0.0.0-alpha.1"
+    "tamedevil": "^0.0.0-alpha.2"
   },
   "peerDependencies": {
     "@envelop/core": "^3.0.4",
-    "graphile-config": "^0.0.1-alpha.1",
+    "graphile-config": "^0.0.1-alpha.2",
     "graphql": "^16.1.0-experimental-stream-defer.6"
   },
   "peerDependenciesMeta": {