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

package/dist/steps/node.d.ts

@@ -1,14 +1,14 @@
 import type { GraphQLObjectType } from "graphql";
-import type { AnyInputStep, ExecutionExtra, NodeIdHandler, PolymorphicData } from "../interfaces.js";
-import type { ExecutableStep, PolymorphicStep } from "../step.js";
-import { UnbatchedExecutableStep } from "../step.js";
+import type { Maybe, NodeIdHandler, PolymorphicData, UnbatchedExecutionExtra } from "../interfaces.js";
+import type { PolymorphicStep, Step } from "../step.js";
+import { UnbatchedStep } from "../step.js";
 /**
  * A plan to get a Node by its global object identifier (string). Accepts an
  * object specifying the supported codecs, an object map detailing the
  * typeNames supported and their details (codec to use, how to find the record,
  * etc), and finally the Node id string plan.
  */
-export declare class NodeStep extends UnbatchedExecutableStep implements PolymorphicStep {
+export declare class NodeStep extends UnbatchedStep implements PolymorphicStep {
     private possibleTypes;
     static $$export: {
         moduleName: string;
@@ -19,10 +19,10 @@ export declare class NodeStep extends UnbatchedExecutableStep implements Polymor
     private specPlanDep;
     constructor(possibleTypes: {
         [typeName: string]: NodeIdHandler;
-    }, $id: ExecutableStep<string | null | undefined>);
-    planForType(type: GraphQLObjectType): ExecutableStep;
+    }, $id: Step<string | null | undefined>);
+    planForType(type: GraphQLObjectType): Step;
     private getTypeNameFromSpecifier;
-    unbatchedExecute: (_extra: ExecutionExtra, specifier: any) => PolymorphicData<string, ReadonlyArray<any>> | null;
+    unbatchedExecute: (_extra: UnbatchedExecutionExtra, specifier: any) => PolymorphicData<string, ReadonlyArray<any>> | null;
 }
 /**
  * A plan to get a Node by its global object identifier (string). Accepts an
@@ -32,9 +32,16 @@ export declare class NodeStep extends UnbatchedExecutableStep implements Polymor
  */
 export declare function node(possibleTypes: {
     [typeName: string]: NodeIdHandler;
-}, $id: ExecutableStep<string | null | undefined>): NodeStep;
-export declare function specFromNodeId(handler: NodeIdHandler<any>, $id: ExecutableStep<string> | AnyInputStep): any;
-export declare function makeDecodeNodeId(handlers: NodeIdHandler[]): ($id: ExecutableStep<string | null | undefined>) => import("./lambda.js").LambdaStep<string | null | undefined, {
+}, $id: Step<string | null | undefined>): NodeStep;
+export declare function specFromNodeId(handler: NodeIdHandler<any>, $id: Step<Maybe<string>>): any;
+export declare function nodeIdFromNode(handler: NodeIdHandler<any>, $node: Step): import("./lambda.js").LambdaStep<any, string | null>;
+export declare function makeDecodeNodeIdRuntime(handlers: readonly NodeIdHandler[]): {
+    (raw: string | null | undefined): {
+        [codecName: string]: any;
+    } | null;
+    isSyncAndSafe: boolean;
+};
+export declare function makeDecodeNodeId(handlers: readonly NodeIdHandler[]): ($id: Step<string | null | undefined>) => import("./lambda.js").LambdaStep<string | null | undefined, {
     [codecName: string]: any;
 } | null>;
 //# sourceMappingURL=node.d.ts.map

package/dist/steps/node.js

@@ -1,6 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeDecodeNodeId = exports.specFromNodeId = exports.node = exports.NodeStep = void 0;
+exports.NodeStep = void 0;
+exports.node = node;
+exports.specFromNodeId = specFromNodeId;
+exports.nodeIdFromNode = nodeIdFromNode;
+exports.makeDecodeNodeIdRuntime = makeDecodeNodeIdRuntime;
+exports.makeDecodeNodeId = makeDecodeNodeId;
 const dev_js_1 = require("../dev.js");
 const inspect_js_1 = require("../inspect.js");
 const polymorphic_js_1 = require("../polymorphic.js");
@@ -14,7 +19,7 @@ const lambda_js_1 = require("./lambda.js");
  * typeNames supported and their details (codec to use, how to find the record,
  * etc), and finally the Node id string plan.
  */
-class NodeStep extends step_js_1.UnbatchedExecutableStep {
+class NodeStep extends step_js_1.UnbatchedStep {
     static { this.$$export = {
         moduleName: "grafast",
         exportName: "NodeStep",
@@ -65,9 +70,10 @@ exports.NodeStep = NodeStep;
 function node(possibleTypes, $id) {
     return new NodeStep(possibleTypes, $id);
 }
-exports.node = node;
 function specFromNodeId(handler, $id) {
     function decodeWithCodecAndHandler(raw) {
+        if (raw == null)
+            return raw;
         try {
             const decoded = handler.codec.decode(raw);
             if (handler.match(decoded)) {
@@ -84,8 +90,11 @@ function specFromNodeId(handler, $id) {
     const $decoded = (0, lambda_js_1.lambda)($id, decodeWithCodecAndHandler);
     return handler.getSpec($decoded);
 }
-exports.specFromNodeId = specFromNodeId;
-function makeDecodeNodeId(handlers) {
+function nodeIdFromNode(handler, $node) {
+    const specifier = handler.plan($node);
+    return (0, lambda_js_1.lambda)(specifier, handler.codec.encode);
+}
+function makeDecodeNodeIdRuntime(handlers) {
     const codecs = [...new Set(handlers.map((h) => h.codec))];
     function decodeNodeIdWithCodecs(raw) {
         if (raw == null)
@@ -101,7 +110,10 @@ function makeDecodeNodeId(handlers) {
         }, { raw });
     }
     decodeNodeIdWithCodecs.isSyncAndSafe = true; // Optimization
+    return decodeNodeIdWithCodecs;
+}
+function makeDecodeNodeId(handlers) {
+    const decodeNodeIdWithCodecs = makeDecodeNodeIdRuntime(handlers);
     return ($id) => (0, lambda_js_1.lambda)($id, decodeNodeIdWithCodecs);
 }
-exports.makeDecodeNodeId = makeDecodeNodeId;
 //# sourceMappingURL=node.js.map

package/dist/steps/object.d.ts

@@ -1,56 +1,62 @@
-import type { ExecutionExtra, StepOptimizeOptions } from "../interfaces.js";
-import type { ExecutableStep } from "../step.js";
-import { UnbatchedExecutableStep } from "../step.js";
+import type { DataFromStep, ExecutionDetails, ExecutionExtra, StepOptimizeOptions, UnbatchedExecutionExtra } from "../interfaces.js";
+import type { Step } from "../step.js";
+import { UnbatchedStep } 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 {
-    [key: string]: ExecutableStep;
+export type DataFromObjectSteps<TSteps extends {
+    [key: string]: Step;
 }> = {
-    [key in keyof TPlans]: DataFromStep<TPlans[key]>;
+    [key in keyof TSteps]: DataFromStep<TSteps[key]>;
 };
-type Results<TPlans extends {
-    [key: string]: ExecutableStep;
+type Results<TSteps extends {
+    [key: string]: Step;
 }> = Array<[
-    Array<DataFromPlans<TPlans>[keyof TPlans]>,
-    DataFromPlans<TPlans>
+    Array<DataFromObjectSteps<TSteps>[keyof TSteps]>,
+    DataFromObjectSteps<TSteps>
 ]>;
-export interface ObjectPlanMeta<TPlans extends {
-    [key: string]: ExecutableStep;
+export interface ObjectPlanMeta<TSteps extends {
+    [key: string]: Step;
 }> {
-    results: Results<TPlans>;
+    results: Results<TSteps>;
+}
+interface ObjectStepCacheConfig {
+    identifier?: string;
+    cacheSize?: number;
 }
 /**
  * A plan that represents an object using the keys given and the values being
  * the results of the associated plans.
  */
 export declare class ObjectStep<TPlans extends {
-    [key: string]: ExecutableStep;
+    [key: string]: Step;
 } = {
-    [key: string]: ExecutableStep;
-}> extends UnbatchedExecutableStep<DataFromPlans<TPlans>> implements SetterCapableStep<TPlans> {
+    [key: string]: Step;
+}> extends UnbatchedStep<DataFromObjectSteps<TPlans>> {
+    private cacheConfig?;
     static $$export: {
         moduleName: string;
         exportName: string;
     };
     isSyncAndSafe: boolean;
     allowMultipleOptimizations: boolean;
-    private keys;
+    private readonly keys;
     optimizeMetaKey: string;
-    constructor(obj: TPlans);
+    private cacheSize;
+    constructor(obj: TPlans, cacheConfig?: ObjectStepCacheConfig | undefined);
+    private _setKeys;
     /**
      * This key doesn't get typed, but it can be added later which can be quite
      * handy.
      */
     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;
+    getStepForKey<TKey extends keyof TPlans>(key: TKey): TPlans[TKey];
+    getStepForKey<TKey extends keyof TPlans>(key: TKey, allowMissing: true): TPlans[TKey] | null;
     toStringMeta(): string;
-    tupleToObjectJIT(callback: (fn: (extra: ExecutionExtra, ...tuple: Array<DataFromPlans<TPlans>[keyof TPlans]>) => DataFromPlans<TPlans>) => void): void;
+    tupleToObjectJIT(callback: (fn: (extra: ExecutionExtra, ...tuple: Array<DataFromObjectSteps<TPlans>[keyof TPlans]>) => DataFromObjectSteps<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;
+    execute({ indexMap, values, extra, }: ExecutionDetails<Array<DataFromObjectSteps<TPlans>[keyof TPlans]>>): ReadonlyArray<DataFromObjectSteps<TPlans>>;
+    unbatchedExecute(_extra: UnbatchedExecutionExtra, ..._values: any[]): any;
     deduplicate(peers: ObjectStep<any>[]): ObjectStep<TPlans>[];
-    optimize(opts: StepOptimizeOptions): this | ConstantStep<any>;
+    optimize(opts: StepOptimizeOptions): ConstantStep<any> | this | ConstantStep<Record<string, any>>;
     /**
      * Get the original plan with the given key back again.
      */
@@ -61,7 +67,7 @@ export declare class ObjectStep<TPlans extends {
  * the results of the associated plans.
  */
 export declare function object<TPlans extends {
-    [key: string]: ExecutableStep;
-}>(obj: TPlans): ObjectStep<TPlans>;
+    [key: string]: Step;
+}>(obj: TPlans, cacheConfig?: ObjectStepCacheConfig): ObjectStep<TPlans>;
 export {};
 //# sourceMappingURL=object.d.ts.map

package/dist/steps/object.js

@@ -1,40 +1,58 @@
 "use strict";
 // import debugFactory from "debug";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.object = exports.ObjectStep = void 0;
+exports.ObjectStep = void 0;
+exports.object = object;
 const tslib_1 = require("tslib");
 const tamedevil_1 = tslib_1.__importStar(require("tamedevil"));
 const step_js_1 = require("../step.js");
+const utils_js_1 = require("../utils.js");
 const constant_js_1 = require("./constant.js");
+const DEFAULT_CACHE_SIZE = 100;
 const EMPTY_OBJECT = Object.freeze(Object.create(null));
 /**
  * A plan that represents an object using the keys given and the values being
  * the results of the associated plans.
  */
-class ObjectStep extends step_js_1.UnbatchedExecutableStep {
+class ObjectStep extends step_js_1.UnbatchedStep {
     static { this.$$export = {
         moduleName: "grafast",
         exportName: "ObjectStep",
     }; }
-    constructor(obj) {
+    constructor(obj, cacheConfig) {
         super();
+        this.cacheConfig = cacheConfig;
         this.isSyncAndSafe = true;
         this.allowMultipleOptimizations = true;
+        this.keys = [];
         // Optimize needs the same 'meta' for all ObjectSteps
         this.optimizeMetaKey = "ObjectStep";
-        this.metaKey = this.id;
-        this.keys = Object.keys(obj);
+        this.cacheSize =
+            cacheConfig?.cacheSize ??
+                (cacheConfig?.identifier ? DEFAULT_CACHE_SIZE : 0);
+        const keys = Object.keys(obj);
+        this._setKeys(keys);
         for (let i = 0, l = this.keys.length; i < l; i++) {
-            this.addDependency(obj[this.keys[i]], true);
+            this.addDependency({ step: obj[keys[i]], skipDeduplication: true });
         }
     }
+    _setKeys(keys) {
+        this.keys = keys;
+        this.peerKey = (0, utils_js_1.digestKeys)(keys);
+        this.metaKey =
+            this.cacheSize <= 0
+                ? undefined
+                : this.cacheConfig?.identifier
+                    ? `object|${this.peerKey}|${this.cacheConfig.identifier}`
+                    : this.id;
+    }
     /**
      * This key doesn't get typed, but it can be added later which can be quite
      * handy.
      */
     set(key, plan) {
-        this.keys.push(key);
-        this.addDependency(plan, true);
+        this._setKeys([...this.keys, key]);
+        this.addDependency({ step: plan, skipDeduplication: true });
     }
     getStepForKey(key, allowMissing = false) {
         const idx = this.keys.indexOf(key);
@@ -44,7 +62,7 @@ class ObjectStep extends step_js_1.UnbatchedExecutableStep {
             }
             return null;
         }
-        return this.getDep(idx);
+        return this.getDepOptions(idx).step;
     }
     toStringMeta() {
         return "{" + this.keys.join(",") + "}";
@@ -52,8 +70,8 @@ class ObjectStep extends step_js_1.UnbatchedExecutableStep {
     /*
     tupleToObject(
       meta: ObjectPlanMeta<TPlans>,
-      ...tuple: Array<DataFromPlans<TPlans>[keyof TPlans]>
-    ): DataFromPlans<TPlans> {
+      ...tuple: Array<DataFromObjectSteps<TPlans>[keyof TPlans]>
+    ): DataFromObjectSteps<TPlans> {
       // Note: `outerloop` is a JavaScript "label". They are not very common.
       // First look for an existing match:
       outerloop: for (let i = 0, l = meta.results.length; i < l; i++) {
@@ -79,7 +97,7 @@ class ObjectStep extends step_js_1.UnbatchedExecutableStep {
       const newObj = this.keys.reduce((memo, key, i) => {
         memo[key] = tuple[i];
         return memo;
-      }, {} as Partial<DataFromPlans<TPlans>>) as DataFromPlans<TPlans>;
+      }, {} as Partial<DataFromObjectSteps<TPlans>>) as DataFromObjectSteps<TPlans>;
   
       // Cache newObj so the same tuple values result in the exact same object.
       meta.results.push([tuple, newObj]);
@@ -102,9 +120,11 @@ ${tamedevil_1.default.join(this.keys.map((key, i) => (0, tamedevil_1.default) `
   const newObj = Object.create(null);
 ${tamedevil_1.default.join(this.keys.map((key, i) => (0, tamedevil_1.default) `  newObj${tamedevil_1.default.set(key, true)} = ${tamedevil_1.default.identifier(`val${i}`)};\n`), "")}\
 `;
-        return tamedevil_1.default.runInBatch((0, tamedevil_1.default) `\
-(function ({ meta }, ${tamedevil_1.default.join(this.keys.map((_k, i) => tamedevil_1.default.identifier(`val${i}`)), ", ")}) {
-  if (meta.nextIndex) {
+        const vals = tamedevil_1.default.join(this.keys.map((_k, i) => tamedevil_1.default.identifier(`val${i}`)), ", ");
+        if (this.cacheSize > 0) {
+            return tamedevil_1.default.runInBatch((0, tamedevil_1.default) `\
+(function ({ meta }, ${vals}) {
+  if (meta.nextIndex != null) {
     for (let i = 0, l = meta.results.length; i < l; i++) {
       const [values, obj] = meta.results[i];
       if (${tamedevil_1.default.join(this.keys.map((_key, i) => (0, tamedevil_1.default) `values[${tamedevil_1.default.lit(i)}] === ${tamedevil_1.default.identifier(`val${i}`)}`), " && ")}) {
@@ -113,16 +133,22 @@ ${tamedevil_1.default.join(this.keys.map((key, i) => (0, tamedevil_1.default) `
     }
   } else {
     meta.nextIndex = 0;
-    if (!meta.results) {
-      meta.results = [];
-    }
+    meta.results = [];
   }
 ${inner}
   meta.results[meta.nextIndex] = [[${tamedevil_1.default.join(this.keys.map((_key, i) => tamedevil_1.default.identifier(`val${i}`)), ",")}], newObj];
-  // Only cache 10 results, use a round-robin
-  meta.nextIndex = meta.nextIndex === 9 ? 0 : meta.nextIndex + 1;
+  // Only cache ${tamedevil_1.default.lit(this.cacheSize)} results, use a round-robin
+  meta.nextIndex = meta.nextIndex === ${tamedevil_1.default.lit(this.cacheSize - 1)} ? 0 : meta.nextIndex + 1;
+  return newObj;
+})`, callback);
+        }
+        else {
+            return tamedevil_1.default.runInBatch((0, tamedevil_1.default) `\
+(function (_, ${vals}) {
+${inner}
   return newObj;
 })`, callback);
+        }
     }
     finalize() {
         this.tupleToObjectJIT((fn) => {
@@ -130,19 +156,15 @@ ${inner}
         });
         return super.finalize();
     }
-    execute(count, values, extra) {
-        const result = [];
-        for (let i = 0; i < count; i++) {
-            result[i] = this.unbatchedExecute(extra, ...values.map((v) => v[i]));
-        }
-        return result;
+    execute({ indexMap, values, extra, }) {
+        return indexMap((i) => this.unbatchedExecute(extra, ...values.map((v) => v.at(i))));
     }
     unbatchedExecute(_extra, ..._values) {
         throw new Error(`${this} didn't finalize? No unbatchedExecute method.`);
     }
     deduplicate(peers) {
-        const myKeys = JSON.stringify(this.keys);
-        return peers.filter((p) => JSON.stringify(p.keys) === myKeys);
+        // Managed through peerKey
+        return peers;
     }
     optimize(opts) {
         if (this.dependencies.every((dep) => dep instanceof constant_js_1.ConstantStep)) {
@@ -180,7 +202,7 @@ ${inner}
         if (index < 0) {
             throw new Error(`This ObjectStep doesn't have key '${String(key)}'; supported keys: '${this.keys.join("', '")}'`);
         }
-        return this.getDep(index);
+        return this.getDepOptions(index).step;
     }
 }
 exports.ObjectStep = ObjectStep;
@@ -188,8 +210,7 @@ exports.ObjectStep = ObjectStep;
  * A plan that represents an object using the keys given and the values being
  * the results of the associated plans.
  */
-function object(obj) {
-    return new ObjectStep(obj);
+function object(obj, cacheConfig) {
+    return new ObjectStep(obj, cacheConfig);
 }
-exports.object = object;
 //# sourceMappingURL=object.js.map

package/dist/steps/partitionByIndex.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";
 /**
  * Takes a single dimensional list plan and a mapper that calculates a
@@ -35,5 +36,5 @@ import type { __ListTransformStep, ListTransformItemPlanCallback } from "./listT
  *
  * Beware: the target indexes should not contain gaps.
  */
-export declare function partitionByIndex<TListStep extends ExecutableStep<readonly any[]>, TItemStep extends ExecutableStep<number>>(listStep: TListStep, mapper: ListTransformItemPlanCallback<TListStep, TItemStep>, startIndex?: 0 | 1): __ListTransformStep<TListStep, TItemStep, unknown[][], any>;
+export declare function partitionByIndex<TListStep extends Step<readonly any[]> | ConnectionCapableStep<any, any>, TItemStep extends Step<number>>(listStep: TListStep, mapper: ListTransformItemPlanCallback<ItemsStep<TListStep>, TItemStep>, startIndex?: 0 | 1): __ListTransformStep<TListStep, TItemStep, unknown[][], any>;
 //# sourceMappingURL=partitionByIndex.d.ts.map

package/dist/steps/partitionByIndex.js

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

package/dist/steps/polymorphicBranch.d.ts

@@ -0,0 +1,27 @@
+import type { GraphQLObjectType } from "graphql";
+import type { ExecutionDetails, GrafastResultsList, PromiseOrDirect } from "../index.js";
+import type { PolymorphicStep } from "../step.js";
+import { Step } from "../step.js";
+type StepData<TStep extends Step> = TStep extends Step<infer U> ? U : any;
+export interface PolymorphicBranchMatchers<TStep extends Step> {
+    [typeName: string]: PolymorphicBranchMatcher<TStep>;
+}
+export interface PolymorphicBranchMatcher<TStep extends Step> {
+    match?: (obj: StepData<TStep>) => boolean;
+    plan?: ($obj: TStep) => Step;
+}
+export declare class PolymorphicBranchStep<TStep extends Step> extends Step implements PolymorphicStep {
+    static $$export: {
+        moduleName: string;
+        exportName: string;
+    };
+    isSyncAndSafe: boolean;
+    private typeNames;
+    private matchers;
+    constructor($step: TStep, matchers: PolymorphicBranchMatchers<TStep>);
+    planForType(objectType: GraphQLObjectType): Step;
+    execute({ indexMap, values: [values0], }: ExecutionDetails): PromiseOrDirect<GrafastResultsList<any>>;
+}
+export declare function polymorphicBranch<TStep extends Step>($step: TStep, matchers: PolymorphicBranchMatchers<TStep>): PolymorphicBranchStep<TStep>;
+export {};
+//# sourceMappingURL=polymorphicBranch.d.ts.map

package/dist/steps/polymorphicBranch.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PolymorphicBranchStep = void 0;
+exports.polymorphicBranch = polymorphicBranch;
+const index_js_1 = require("../index.js");
+const step_js_1 = require("../step.js");
+const constant_js_1 = require("./constant.js");
+class PolymorphicBranchStep extends step_js_1.Step {
+    static { this.$$export = {
+        moduleName: "grafast",
+        exportName: "PolymorphicBranchStep",
+    }; }
+    constructor($step, matchers) {
+        super();
+        this.isSyncAndSafe = true;
+        this.addDependency($step);
+        this.typeNames = Object.keys(matchers);
+        this.matchers = Object.fromEntries(Object.entries(matchers).map(([typeName, matcher]) => {
+            const fixedMatcher = {
+                match: matcher.match ?? ((obj) => obj.__typename === typeName),
+                plan: matcher.plan ?? (($obj) => $obj),
+            };
+            return [typeName, fixedMatcher];
+        }));
+    }
+    planForType(objectType) {
+        const matcher = this.matchers[objectType.name];
+        const $step = this.getDep(0, true);
+        if (matcher) {
+            if (typeof matcher.plan === "function") {
+                return matcher.plan($step);
+            }
+            else {
+                return $step;
+            }
+        }
+        else {
+            // TODO: should this be an error?
+            return (0, constant_js_1.constant)(null);
+        }
+    }
+    execute({ indexMap, values: [values0], }) {
+        return indexMap((i) => {
+            const obj = values0.at(i);
+            let match = null;
+            if (obj != null) {
+                for (const typeName of this.typeNames) {
+                    if (this.matchers[typeName].match(obj)) {
+                        match = typeName;
+                        break;
+                    }
+                }
+            }
+            return match !== null ? (0, index_js_1.polymorphicWrap)(match, obj) : null;
+        });
+    }
+}
+exports.PolymorphicBranchStep = PolymorphicBranchStep;
+function polymorphicBranch($step, matchers) {
+    return new PolymorphicBranchStep($step, matchers);
+}
+//# sourceMappingURL=polymorphicBranch.js.map

package/dist/steps/proxy.d.ts

@@ -1,29 +1,28 @@
-import type { GrafastResultsList, GrafastValuesList } from "../index.js";
-import type { ExecutionExtra } from "../interfaces.js";
+import type { ExecutionDetails, GrafastResultsList, UnbatchedExecutionExtra } from "../interfaces.js";
 import { $$proxy } from "../interfaces.js";
-import type { ExecutableStep } from "../step.js";
-import { UnbatchedExecutableStep } from "../step.js";
+import type { Step } from "../step.js";
+import { UnbatchedStep } from "../step.js";
 /**
  * @experimental
  *
  * Never build this class directly.
  */
-export declare class ProxyStep<T> extends UnbatchedExecutableStep<T> {
+export declare class ProxyStep<T> extends UnbatchedStep<T> {
     static $$export: {
         moduleName: string;
         exportName: string;
     };
     isSyncAndSafe: boolean;
     private $depId;
-    constructor($dep: ExecutableStep<T>, $actualDep: ExecutableStep);
+    constructor($dep: Step<T>, $actualDep: Step);
     toStringMeta(): string | null;
-    addDependency(step: ExecutableStep): number;
-    execute(_count: number, values: [GrafastValuesList<T>]): GrafastResultsList<T>;
-    unbatchedExecute(_extra: ExecutionExtra, value: T): T;
+    addDependency(step: Step): number;
+    execute({ count, values: [values0], }: ExecutionDetails<[T]>): GrafastResultsList<T>;
+    unbatchedExecute(_extra: UnbatchedExecutionExtra, value: T): T;
     stream: undefined;
 }
 declare module "../step.js" {
-    interface ExecutableStep {
+    interface Step {
         [$$proxy]?: any;
     }
 }
@@ -33,7 +32,7 @@ declare module "../step.js" {
  * This could change at any time, may impact performance, and just, generally,
  * needs more work. You shouldn't need this in the vast majority of cases.
  */
-export declare function proxy<TData, TStep extends ExecutableStep<TData>>($step: TStep, $actualDep?: ExecutableStep): TStep & {
-    addDependency(step: ExecutableStep): number;
+export declare function proxy<TData, TStep extends Step<TData>>($step: TStep, $actualDep?: Step): TStep & {
+    addDependency(step: Step): number;
 };
 //# sourceMappingURL=proxy.d.ts.map

package/dist/steps/proxy.js

@@ -1,14 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.proxy = exports.ProxyStep = void 0;
+exports.ProxyStep = void 0;
+exports.proxy = proxy;
 const interfaces_js_1 = require("../interfaces.js");
 const step_js_1 = require("../step.js");
+const utils_js_1 = require("../utils.js");
 /**
  * @experimental
  *
  * Never build this class directly.
  */
-class ProxyStep extends step_js_1.UnbatchedExecutableStep {
+class ProxyStep extends step_js_1.UnbatchedStep {
     static { this.$$export = {
         moduleName: "grafast",
         exportName: "ProxyStep",
@@ -29,8 +31,10 @@ class ProxyStep extends step_js_1.UnbatchedExecutableStep {
     addDependency(step) {
         return super.addDependency(step);
     }
-    execute(_count, values) {
-        return values[0];
+    execute({ count, values: [values0], }) {
+        return values0.isBatch
+            ? values0.entries
+            : (0, utils_js_1.arrayOfLength)(count, values0.value);
     }
     unbatchedExecute(_extra, value) {
         return value;
@@ -110,5 +114,4 @@ function proxy($step, $actualDep = $step) {
     $proxy[interfaces_js_1.$$proxy] = proxy;
     return proxy;
 }
-exports.proxy = proxy;
 //# sourceMappingURL=proxy.js.map

package/dist/steps/remapKeys.d.ts

@@ -1,6 +1,6 @@
-import type { ExecutionExtra, GrafastResultsList, GrafastValuesList } from "../interfaces.js";
-import type { ExecutableStep } from "../step.js";
-import { UnbatchedExecutableStep } from "../step.js";
+import type { ExecutionDetails, GrafastResultsList, UnbatchedExecutionExtra } from "../interfaces.js";
+import type { Step } from "../step.js";
+import { UnbatchedStep } from "../step.js";
 export type ActualKeyByDesiredKey = {
     [desiredKey: string]: string;
 };
@@ -8,8 +8,8 @@ export type ActualKeyByDesiredKey = {
  * A plan that returns an object resulting from extracting the given
  * `actualKey` from the input and storing it as the `desiredKey` in the output.
  */
-export declare class RemapKeysStep extends UnbatchedExecutableStep {
-    private actualKeyByDesiredKey;
+export declare class RemapKeysStep extends UnbatchedStep {
+    private readonly actualKeyByDesiredKey;
     static $$export: {
         moduleName: string;
         exportName: string;
@@ -17,19 +17,19 @@ export declare class RemapKeysStep extends UnbatchedExecutableStep {
     isSyncAndSafe: boolean;
     allowMultipleOptimizations: boolean;
     private mapper;
-    constructor($plan: ExecutableStep, actualKeyByDesiredKey: ActualKeyByDesiredKey);
+    constructor($plan: Step, actualKeyByDesiredKey: ActualKeyByDesiredKey);
     toStringMeta(): string;
-    optimize(): ExecutableStep<any> | this;
+    optimize(): Step<any> | this;
     finalize(): void;
-    execute(_count: number, values: GrafastValuesList<any[]>): GrafastResultsList<any>;
-    unbatchedExecute(_extra: ExecutionExtra, value: any): any;
+    execute({ count, values: [values0], }: ExecutionDetails): GrafastResultsList<any>;
+    unbatchedExecute(_extra: UnbatchedExecutionExtra, value: any): any;
     deduplicate(peers: RemapKeysStep[]): RemapKeysStep[];
 }
 /**
  * A plan that returns an object resulting from extracting the given
  * `actualKey` from the input and storing it as the `desiredKey` in the output.
  */
-export declare function remapKeys($step: ExecutableStep, actualKeyByDesiredKey: {
+export declare function remapKeys($step: Step, actualKeyByDesiredKey: {
     [desiredKey: string]: string;
 }): RemapKeysStep;
 //# sourceMappingURL=remapKeys.d.ts.map