@elaraai/e3-types 1.0.78 → 1.0.80

package/dist/src/task.d.ts

@@ -5,75 +5,184 @@
 /**
  * Task object types for e3.
  *
- * A task object defines a complete executable unit: the command IR that
- * generates the exec args, where to read inputs from, and where to write output.
+ * A task object says what a task runs, on which runtime, over which datasets,
+ * and what its output is: every field a mode used to be implied by is typed.
+ * Task objects are stored in the object store and referenced by packages, so
+ * they are content-addressed, which is what memoizes their executions.
  *
- * Task objects are stored in the object store and referenced by packages.
- * They are content-addressed, enabling deduplication and memoization.
+ * Input and output types are not stored here: they are the package structure's
+ * at the paths the task names.
+ */
+import { StructType, StringType, ArrayType, NullType, OptionType, VariantType, ValueTypeOf } from '@elaraai/east';
+/** The kind tag every task object carries, which the garbage collector
+ *  dispatches on. */
+export declare const TASK_OBJECT_KIND = "$task";
+/**
+ * What a task runs.
  *
- * Input and output types are inferred from the package's structure at the
- * specified paths - the task just references locations, not types.
+ * - `east`: an East program, which a stock runner executes as a unit
+ *   (`exec`): `program` is the hash of its IR bundle.
+ * - `command`: a command, which the custom runtime spawns. `commandIr` is the
+ *   hash of the IR bundle of the East function that builds its argv,
+ *   `(inputs: Array<String>, output: String) -> Array<String>`.
+ */
+export declare const TaskBodyType: VariantType<{
+    readonly east: StructType<{
+        readonly program: StringType;
+    }>;
+    readonly command: StructType<{
+        readonly commandIr: StringType;
+    }>;
+}>;
+export type TaskBodyType = typeof TaskBodyType;
+export type TaskBody = ValueTypeOf<typeof TaskBodyType>;
+/**
+ * An input the work may be split over: `by` names the leading key fields
+ * whose equal values are never split across pieces — a field, or a
+ * first-field path written `a.b`. Empty when any key may start a piece.
+ */
+export declare const TaskPartitionType: StructType<{
+    readonly by: ArrayType<StringType>;
+}>;
+export type TaskPartitionType = typeof TaskPartitionType;
+export type TaskPartition = ValueTypeOf<typeof TaskPartitionType>;
+/** A dataset a task reads, and whether the work may be split over it. */
+export declare const TaskInputType: StructType<{
+    readonly path: ArrayType<VariantType<{
+        readonly field: StringType;
+    }>>;
+    readonly partition: OptionType<StructType<{
+        readonly by: ArrayType<StringType>;
+    }>>;
+}>;
+export type TaskInputType = typeof TaskInputType;
+export type TaskInput = ValueTypeOf<typeof TaskInputType>;
+/**
+ * How a task's output is made, which fixes how the parts of it that units
+ * write combine.
+ *
+ * - `value`: the program returns it.
+ * - `array`: emitted elements, concatenated in emission order.
+ * - `set`: emitted elements, in any order, unioned.
+ * - `dict`: emitted entries, in any order; equal keys fold with `merge`, the
+ *   hash of a `(K, V, V) -> V` IR bundle, and without it are refused.
+ * - `fold`: emitted values folded with `combine`, the hash of a `(T, T) -> T`
+ *   IR bundle, starting at `zero`, the hash of a stored value.
  */
-import { StructType, StringType, ArrayType, BlobType, BooleanType, IntegerType, OptionType, ValueTypeOf } from '@elaraai/east';
-import type { EastTypeValue, FunctionIR } from '@elaraai/east';
+export declare const TaskOutputKindType: VariantType<{
+    readonly value: NullType;
+    readonly array: NullType;
+    readonly set: NullType;
+    readonly dict: StructType<{
+        readonly merge: OptionType<StringType>;
+    }>;
+    readonly fold: StructType<{
+        readonly zero: StringType;
+        readonly combine: StringType;
+    }>;
+}>;
+export type TaskOutputKindType = typeof TaskOutputKindType;
+export type TaskOutputKind = ValueTypeOf<typeof TaskOutputKindType>;
+/** Where a task's output goes, and how it is made. */
+export declare const TaskOutputType: StructType<{
+    readonly path: ArrayType<VariantType<{
+        readonly field: StringType;
+    }>>;
+    readonly kind: VariantType<{
+        readonly value: NullType;
+        readonly array: NullType;
+        readonly set: NullType;
+        readonly dict: StructType<{
+            readonly merge: OptionType<StringType>;
+        }>;
+        readonly fold: StructType<{
+            readonly zero: StringType;
+            readonly combine: StringType;
+        }>;
+    }>;
+}>;
+export type TaskOutputType = typeof TaskOutputType;
+export type TaskOutput = ValueTypeOf<typeof TaskOutputType>;
+/**
+ * What a ui task binds as it renders.
+ *
+ * @property paths - Dataset paths it reads or writes through `Data.bind`,
+ *   including each bound record's own path, so the record's current value is
+ *   preloaded and polled like any dataset.
+ * @property functions - Package functions it calls through `Func.bind`.
+ * @property records - Records it binds through `Record.bind`.
+ * @property pages - Dataset paths it reads a window at a time through
+ *   `Data.bindPaged`: declared apart from `paths` because they are never
+ *   preloaded or polled whole.
+ */
+export declare const DataManifestType: StructType<{
+    readonly paths: ArrayType<ArrayType<VariantType<{
+        readonly field: StringType;
+    }>>>;
+    readonly functions: ArrayType<StringType>;
+    readonly records: ArrayType<StringType>;
+    readonly pages: ArrayType<ArrayType<VariantType<{
+        readonly field: StringType;
+    }>>>;
+}>;
+export type DataManifestType = typeof DataManifestType;
+export type DataManifest = ValueTypeOf<typeof DataManifestType>;
+/**
+ * What a task's output is for: `data`, or a `ui` whose output is a component
+ * tree rendered against the datasets, functions and records it binds.
+ */
+export declare const TaskRoleType: VariantType<{
+    readonly data: NullType;
+    readonly ui: StructType<{
+        readonly paths: ArrayType<ArrayType<VariantType<{
+            readonly field: StringType;
+        }>>>;
+        readonly functions: ArrayType<StringType>;
+        readonly records: ArrayType<StringType>;
+        readonly pages: ArrayType<ArrayType<VariantType<{
+            readonly field: StringType;
+        }>>>;
+    }>;
+}>;
+export type TaskRoleType = typeof TaskRoleType;
+export type TaskRole = ValueTypeOf<typeof TaskRoleType>;
 /**
  * Task object stored in the object store.
  *
- * A task is a complete executable unit that reads from input dataset paths
- * and writes to an output dataset path. The commandIr is evaluated at runtime
- * to produce the exec args.
- *
  * @remarks
- * - `commandIr`: Hash of East IR object that produces exec args
- *   - IR signature: (inputs: Array<String>, output: String) -> Array<String>
- *   - `inputs` are paths to staged input .beast2 files
- *   - `output` is the path where output should be written
- *   - Returns array of strings to exec (e.g., ["sh", "-c", "python ..."])
- * - `inputs`: Paths to input datasets in the data tree
- * - `output`: Path to the output dataset in the data tree
- *
- * Types are not stored in the task - they are inferred from the package's
- * structure at the specified paths. This keeps tasks simple and avoids
- * redundant type information.
+ * A package-borne wire, so it changes by hard cutover: a package exported by
+ * an older SDK is re-exported, and {@link decodeTaskObject} says so.
  *
  * @example
  * ```ts
- * import { variant } from '@elaraai/east';
+ * import { none, variant } from '@elaraai/east';
  *
- * // Task with command IR that generates: ["sh", "-c", "python script.py <input> <output>"]
  * const task: TaskObject = {
- *   commandIr: '5e7a3b...',  // hash of compiled IR
- *   inputs: [
- *     [variant('field', 'inputs'), variant('field', 'sales')],
- *   ],
- *   output: [variant('field', 'tasks'), variant('field', 'train'), variant('field', 'output')],
+ *   kind: TASK_OBJECT_KIND,
+ *   body: variant('east', { program: '5e7a3b...' }),
+ *   runner: variant('east_node', { platforms: ['@elaraai/east-node-std'] }),
+ *   inputs: [{ path: [variant('field', 'inputs'), variant('field', 'sales')], partition: none }],
+ *   output: { path: [variant('field', 'tasks'), variant('field', 'totals'), variant('field', 'output')], kind: variant('value', null) },
+ *   role: variant('data', null),
+ *   environment: none,
  * };
  * ```
  */
 export declare const TaskObjectType: StructType<{
-    /** Hash of East IR that generates exec args: (inputs, output) -> Array<String> */
-    readonly commandIr: StringType;
-    /** Input paths: where to read each input dataset from the data tree */
-    readonly inputs: ArrayType<ArrayType<import("@elaraai/east").VariantType<{
-        readonly field: StringType;
-    }>>>;
-    /** Output path: where to write the output dataset in the data tree */
-    readonly output: ArrayType<import("@elaraai/east").VariantType<{
-        readonly field: StringType;
-    }>>;
-    /** Task kind: "data" (default), "ui", or future extensions. None for old packages. */
-    readonly kind: OptionType<StringType>;
-    /** Opaque extension metadata (beast2-encoded). Interpreted by the kind-specific consumer. */
-    readonly metadata: OptionType<BlobType>;
-    /**
-     * The task's runner, as routing metadata (symmetric with
-     * FunctionObject.runner). For `custom` runners, `commandIr` remains
-     * authoritative for execution — the wire command is informational.
-     *
-     * NOTE: added as a hard cutover (no dual decoder) — packages exported by
-     * older SDKs must be re-exported.
-     */
-    readonly runner: import("@elaraai/east").VariantType<{
+    /** Always {@link TASK_OBJECT_KIND}. */
+    readonly kind: StringType;
+    /** What the task runs. */
+    readonly body: VariantType<{
+        readonly east: StructType<{
+            readonly program: StringType;
+        }>;
+        readonly command: StructType<{
+            readonly commandIr: StringType;
+        }>;
+    }>;
+    /** The runtime it runs on. A `custom` runner's command is informational:
+     *  the body's command IR is what spawns. */
+    readonly runner: VariantType<{
         readonly east_node: StructType<{
             readonly platforms: ArrayType<StringType>;
         }>;
@@ -87,277 +196,60 @@ export declare const TaskObjectType: StructType<{
             readonly command: ArrayType<StringType>;
         }>;
     }>;
-    /**
-     * Hash of an {@link EnvironmentSpecType} object the task executes in;
-     * `none` ⇒ the stock runtime image. Appended LAST (BEAST2 encodes struct
-     * fields positionally) with a legacy dual decoder — see
-     * {@link decodeTaskObject}.
-     */
+    /** The datasets it reads, in the order its program takes them. */
+    readonly inputs: ArrayType<StructType<{
+        readonly path: ArrayType<VariantType<{
+            readonly field: StringType;
+        }>>;
+        readonly partition: OptionType<StructType<{
+            readonly by: ArrayType<StringType>;
+        }>>;
+    }>>;
+    /** Where its output goes, and how it is made. */
+    readonly output: StructType<{
+        readonly path: ArrayType<VariantType<{
+            readonly field: StringType;
+        }>>;
+        readonly kind: VariantType<{
+            readonly value: NullType;
+            readonly array: NullType;
+            readonly set: NullType;
+            readonly dict: StructType<{
+                readonly merge: OptionType<StringType>;
+            }>;
+            readonly fold: StructType<{
+                readonly zero: StringType;
+                readonly combine: StringType;
+            }>;
+        }>;
+    }>;
+    /** What its output is for. */
+    readonly role: VariantType<{
+        readonly data: NullType;
+        readonly ui: StructType<{
+            readonly paths: ArrayType<ArrayType<VariantType<{
+                readonly field: StringType;
+            }>>>;
+            readonly functions: ArrayType<StringType>;
+            readonly records: ArrayType<StringType>;
+            readonly pages: ArrayType<ArrayType<VariantType<{
+                readonly field: StringType;
+            }>>>;
+        }>;
+    }>;
+    /** Hash of the {@link EnvironmentSpecType} object it executes in; `none`
+     *  for the stock runtime image. */
     readonly environment: OptionType<StringType>;
 }>;
 export type TaskObjectType = typeof TaskObjectType;
 export type TaskObject = ValueTypeOf<typeof TaskObjectType>;
 /**
- * Decode a `TaskObject` from BEAST2 bytes, tolerating the pre-`environment`
- * wire format (dual-decode migration, like {@link decodePackageObject}).
+ * Decode a `TaskObject` from BEAST2 bytes.
  *
- * Every task-read path — local AND cloud — must use this instead of
- * `decodeBeast2For(TaskObjectType)` directly. Older bytes decode with
- * `environment` defaulted to `none`.
+ * @param data - the stored bytes
+ * @returns the task object
+ * @throws {Error} When the bytes are not a current task object — a package
+ *   exported by an older SDK, which is re-exported with the current one.
  */
 export declare function decodeTaskObject(data: Uint8Array): TaskObject;
-/** Task kind of a partitioned task — the orchestrator carves its partitioned
- *  input(s) into key-range slices, runs each slice as an ordinary
- *  content-addressed execution, and assembles the output by splice or by
- *  combining partials. The spec rides {@link TaskObjectType}'s `metadata`
- *  slot as a beast2-encoded {@link PartitionTaskMetadataType}. */
-export declare const TASK_KIND_PARTITION = "partition";
-/** Task kind of a streaming task — one execution whose runner feeds the
- *  stream input lazily and writes the output incrementally through an `emit`
- *  capability. The spec rides {@link TaskObjectType}'s `metadata` slot as a
- *  beast2-encoded {@link StreamTaskMetadataType}. */
-export declare const TASK_KIND_STREAM = "stream";
-/** Task kind of a merge unit — the runner's `merge` command over sorted
- *  partials of a partitioned task's keyed output (issue #770). The
- *  orchestrator writes one such task per partitioned task from the
- *  package's {@link PartitionTaskMetadataType} `mergeCommand`, and runs it
- *  as an ordinary content-addressed execution per group of partials. It
- *  carries no metadata. */
-export declare const TASK_KIND_MERGE = "merge";
-/**
- * Metadata of a {@link TASK_KIND_PARTITION} task.
- *
- * The task's wire `inputs` are laid out `[function_ir, ...partitions,
- * ...inputs]`, so `partitions` counts how many entries after the function IR
- * are partitioned datasets; the rest are ordinary (broadcast) inputs that
- * hash into every partition execution's identity.
- *
- * `by` and `combine` are carried as `encodeEastIR` bundles (capture-free IR +
- * its source map), not as FunctionType values or object-store hashes: IR is
- * how executable code travels everywhere on the e3 wire (`commandIr`,
- * `function_ir`, `bodyIr`), a FunctionType value could smuggle captures the
- * orchestrator must not evaluate, and inline bytes stay reachable where a
- * hash inside an opaque metadata blob would be invisible to GC.
- */
-export declare const PartitionTaskMetadataType: StructType<{
-    /** Number of partitioned inputs (wire input indices `1..1+partitions`). */
-    readonly partitions: IntegerType;
-    /** `encodeEastIR` bundle of the boundary-alignment projection
-     *  `(Key) -> Projection`; `none` when partitioning is free per row/segment. */
-    readonly by: OptionType<BlobType>;
-    /** `encodeEastIR` bundle of the associative fold `(Out, Out) -> Out`;
-     *  `none` in splice mode (shards concatenate). */
-    readonly combine: OptionType<BlobType>;
-    /** Target carved-slice size in wire bytes — the only sizing knob. */
-    readonly targetPartitionBytes: IntegerType;
-    /**
-     * `encodeEastIR` bundle of the per-key merge `(Key, Value, Value) -> Value`
-     * for a Dict output; `none` otherwise.
-     *
-     * Its presence (or {@link mergeSets}) selects the MERGE-TREE assembly:
-     * partials whose key ranges overlap are merged by the task's own runner, in
-     * a tree of merge executions ({@link mergeCommand}) folding equal keys with
-     * this function; disjoint partials are spliced; the orchestrator never
-     * decodes a partial. Appended after `targetPartitionBytes` (BEAST2 encodes
-     * struct fields positionally) with a dual decoder — see
-     * {@link decodePartitionTaskMetadata}.
-     */
-    readonly merge: OptionType<BlobType>;
-    /** Whether a Set output assembles by the merge tree, keeping one of equal
-     *  elements (`--union`). The Set twin of {@link merge}, which needs no
-     *  function. */
-    readonly mergeSets: BooleanType;
-    /**
-     * `encodeEastIR` bundle of the merge command `(input_paths, output_path) ->
-     * argv` — `mergeCommandIr` over the task's runner, in `function` mode with
-     * {@link merge} and `union` mode with {@link mergeSets} — that the
-     * orchestrator's merge units execute; `none` in splice and combine modes.
-     * Built at export, so the merge unit task is a package object like any
-     * other and nothing is synthesized at run time. Appended LAST with a
-     * triple decoder — see {@link decodePartitionTaskMetadata}.
-     */
-    readonly mergeCommand: OptionType<BlobType>;
-}>;
-export type PartitionTaskMetadataType = typeof PartitionTaskMetadataType;
-export type PartitionTaskMetadata = ValueTypeOf<typeof PartitionTaskMetadataType>;
-/** Encode a {@link PartitionTaskMetadataType} value for `TaskObject.metadata`. */
-export declare const encodePartitionTaskMetadata: (value: PartitionTaskMetadata) => Uint8Array;
-/**
- * Decode a `TaskObject.metadata` blob of a {@link TASK_KIND_PARTITION} task,
- * tolerating the two older wire formats: the v1.0.77 shape without
- * `mergeCommand`, and the pre-`merge` shape.
- *
- * @param data - the metadata blob
- * @returns the decoded metadata, with `mergeCommand` (and, for the oldest
- *   bytes, `merge`/`mergeSets`) defaulted off
- */
-export declare function decodePartitionTaskMetadata(data: Uint8Array): PartitionTaskMetadata;
-/**
- * Metadata of a {@link TASK_KIND_STREAM} task.
- *
- * The task's wire `inputs` are laid out `[function_ir, merge_ir?, stream?,
- * ...inputs]` — `merge_ir` only in `function` merge mode; the compiled body
- * takes one trailing `emit` parameter beyond the wire inputs, and the runner
- * writes the `-o` file from the emit sink instead of the body's (Null) return
- * value.
- */
-export declare const StreamTaskMetadataType: StructType<{
-    /** Whether the first input after the IRs is the streamed input (producer
-     *  tasks have no streamed input). */
-    readonly stream: BooleanType;
-    /** The output collection kind the emit sink writes: `"array"`, `"set"`, or
-     *  `"dict"` — element/key/value types come from the body IR's emit
-     *  parameter. */
-    readonly emit: StringType;
-    /**
-     * How the emit sink treats equal keys, a `StreamMergeMode`: `"none"` —
-     * a duplicate key is an error; `"function"` — wire input 1 is the merge IR
-     * `(K, V, V) -> V`, folding equal Dict keys; `"union"` — equal Set elements
-     * collapse. Appended LAST (BEAST2 encodes struct fields positionally) with a
-     * dual decoder — see {@link decodeStreamTaskMetadata}.
-     */
-    readonly merge: StringType;
-}>;
-export type StreamTaskMetadataType = typeof StreamTaskMetadataType;
-export type StreamTaskMetadata = ValueTypeOf<typeof StreamTaskMetadataType>;
-/** Encode a {@link StreamTaskMetadataType} value for `TaskObject.metadata`. */
-export declare const encodeStreamTaskMetadata: (value: StreamTaskMetadata) => Uint8Array;
-/**
- * Decode a `TaskObject.metadata` blob of a {@link TASK_KIND_STREAM} task,
- * tolerating the pre-`merge` wire format (dual-decode migration).
- *
- * @param data - the metadata blob
- * @returns the decoded metadata, with `merge` defaulted to `"none"` for older
- *   bytes
- */
-export declare function decodeStreamTaskMetadata(data: Uint8Array): StreamTaskMetadata;
-/**
- * The plan of one merged component's fan-in (issue #770): the partials whose
- * key ranges overlap, and the key ranges its merge units run over, as the
- * hashes of the range blobs the units take as their input.
- *
- * @remarks
- * The ranges are a pure function of the partials and the task's
- * `targetPartitionBytes` — the boundary keys are fences of the largest
- * partial — so a re-run whose partials are the same objects plans the same
- * ranges; recording them lets it skip the planning probes, and because
- * every unit's inputs are then the same objects, every merge unit
- * cache-hits.
- */
-export declare const MergeRangePlanType: StructType<{
-    /** The component's partial hashes, in partition order. */
-    readonly partials: ArrayType<StringType>;
-    /** The hashes of the component's range blobs — `Struct{from: Option<K>,
-     *  to: Option<K>}` over the output's key type — in key order; one open
-     *  range for a component that merges whole. */
-    readonly ranges: ArrayType<StringType>;
-}>;
-export type MergeRangePlanType = typeof MergeRangePlanType;
-export type MergeRangePlan = ValueTypeOf<typeof MergeRangePlanType>;
-/**
- * The plan of a partitioned execution (issue #770): the partitioned inputs,
- * where each partition starts in every one of them, the carved slices, and
- * the ranged fan-in of each merged component.
- *
- * @remarks
- * The step interpreter writes it to the object store as the run goes —
- * after the map step with the carved slices, and again after the reduce
- * step has planned each component's merge ranges — and points the `plan`
- * sidecar of the execution's `(taskHash, inputsHash)` directory at it, so a
- * re-plan or a resume that computes the same `partitions`/`boundaries`/
- * `splits` reuses the slices instead of carving them again, partition by
- * partition, and a component of the same partials reuses its ranges.
- */
-export declare const PartitionPlanType: StructType<{
-    /** Partitioned input hashes, wire order. */
-    readonly partitions: ArrayType<StringType>;
-    /** First segment index of each partition of the primary; boundaries[0] = 0. */
-    readonly boundaries: ArrayType<IntegerType>;
-    /** Per secondary (partitions[1..]): the split point of every partition plus the end; length boundaries.length + 1. */
-    readonly splits: ArrayType<ArrayType<StructType<{
-        readonly seg: IntegerType;
-        readonly offset: IntegerType;
-    }>>>;
-    /** slices[input][partition] object hashes; empty until carved. */
-    readonly slices: ArrayType<ArrayType<StringType>>;
-    /** The ranged fan-in of each merged component, once its ranges are
-     *  planned. Appended LAST (BEAST2 encodes struct fields positionally) with
-     *  a dual decoder — see {@link decodePartitionPlan}. */
-    readonly merges: ArrayType<StructType<{
-        /** The component's partial hashes, in partition order. */
-        readonly partials: ArrayType<StringType>;
-        /** The hashes of the component's range blobs — `Struct{from: Option<K>,
-         *  to: Option<K>}` over the output's key type — in key order; one open
-         *  range for a component that merges whole. */
-        readonly ranges: ArrayType<StringType>;
-    }>>;
-}>;
-export type PartitionPlanType = typeof PartitionPlanType;
-export type PartitionPlan = ValueTypeOf<typeof PartitionPlanType>;
-/** Encode a {@link PartitionPlanType} value for the object store. */
-export declare const encodePartitionPlan: (value: PartitionPlan) => Uint8Array;
-/**
- * Decode a {@link PartitionPlanType} object, tolerating the pre-`merges`
- * wire shape (dual-decode migration): an older plan decodes with no recorded
- * merge ranges, so its partition slices are reused and its ranges planned.
- *
- * @param data - the plan object's bytes
- * @returns the decoded plan
- */
-export declare function decodePartitionPlan(data: Uint8Array): PartitionPlan;
-/**
- * The shape a partition task's `by` projection reads, as extracted from its
- * IR by {@link partitionProjectionShape}.
- *
- * - `fields`: the identity (`names: []`), or a leading prefix of the key's
- *   top-level fields — one field, or a struct literal of fields in declared
- *   order. Validated against each dataset's top-level key field order.
- * - `path`: a nested leading-field path (`key.a.b`, two or more steps).
- *   Validated per step: each must read the FIRST field of its level's
- *   struct, which is what keeps the projection monotone in canonical key
- *   order.
- */
-export interface ProjectionShape {
-    /** Top-level fields (or the identity), or a nested first-field path. */
-    kind: 'fields' | 'path';
-    /** The fields read, in order; empty for the identity. */
-    names: string[];
-}
-/**
- * Extracts the shape a `by` projection reads — see {@link ProjectionShape} —
- * or `null` for any other (unaccepted) shape.
- *
- * @param ir - the projection's function IR, `(Key) -> Projection`
- * @returns the shape, or `null` when the body is not an accepted projection
- */
-export declare function partitionProjectionShape(ir: FunctionIR): ProjectionShape | null;
-/**
- * The East type of a projected key — the type {@link projectKey} values have,
- * and the one to build their comparator for: the key type itself for the
- * identity, a struct of the named leading fields in declared order, or the
- * type at the end of a nested first-field path.
- *
- * @param shape - the projection's shape
- * @param keyType - the partitioned dataset's key type
- * @returns the projected key type
- * @throws {Error} When the shape reads a field the key type does not have.
- *
- * @example
- * ```ts
- * const cmp = compareFor(projectedKeyType(shape, keyTypeValue));
- * cmp(projectKey(shape, a), projectKey(shape, b));
- * ```
- */
-export declare function projectedKeyType(shape: ProjectionShape, keyType: EastTypeValue): EastTypeValue;
-/**
- * Projects a partition key through a `by` shape, without compiling the
- * projection: the key itself for the identity, a struct of the named leading
- * fields built field by field in declared order, or the value at the end of a
- * nested first-field path.
- *
- * @param shape - the projection's shape
- * @param key - a key of the partitioned dataset
- * @returns the projected key, a value of {@link projectedKeyType}
- */
-export declare function projectKey(shape: ProjectionShape, key: unknown): unknown;
 //# sourceMappingURL=task.d.ts.map

package/dist/src/task.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"task.d.ts","sourceRoot":"","sources":["../../src/task.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"task.d.ts","sourceRoot":"","sources":["../../src/task.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,SAAS,EAAE,QAAQ,EAAE,UAAU,EAAE,WAAW,EAAE,WAAW,EAAmB,MAAM,eAAe,CAAC;AAInI;qBACqB;AACrB,eAAO,MAAM,gBAAgB,UAAU,CAAC;AAExC;;;;;;;;GAQG;AACH,eAAO,MAAM,YAAY;;;;;;;EAGvB,CAAC;AACH,MAAM,MAAM,YAAY,GAAG,OAAO,YAAY,CAAC;AAC/C,MAAM,MAAM,QAAQ,GAAG,WAAW,CAAC,OAAO,YAAY,CAAC,CAAC;AAExD;;;;GAIG;AACH,eAAO,MAAM,iBAAiB;;EAA4C,CAAC;AAC3E,MAAM,MAAM,iBAAiB,GAAG,OAAO,iBAAiB,CAAC;AACzD,MAAM,MAAM,aAAa,GAAG,WAAW,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAElE,yEAAyE;AACzE,eAAO,MAAM,aAAa;;;;;;;EAGxB,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,OAAO,aAAa,CAAC;AACjD,MAAM,MAAM,SAAS,GAAG,WAAW,CAAC,OAAO,aAAa,CAAC,CAAC;AAE1D;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;EAM7B,CAAC;AACH,MAAM,MAAM,kBAAkB,GAAG,OAAO,kBAAkB,CAAC;AAC3D,MAAM,MAAM,cAAc,GAAG,WAAW,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEpE,sDAAsD;AACtD,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;EAGzB,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAC;AACnD,MAAM,MAAM,UAAU,GAAG,WAAW,CAAC,OAAO,cAAc,CAAC,CAAC;AAE5D;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;EAK3B,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,OAAO,gBAAgB,CAAC;AACvD,MAAM,MAAM,YAAY,GAAG,WAAW,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAEhE;;;GAGG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;EAGvB,CAAC;AACH,MAAM,MAAM,YAAY,GAAG,OAAO,YAAY,CAAC;AAC/C,MAAM,MAAM,QAAQ,GAAG,WAAW,CAAC,OAAO,YAAY,CAAC,CAAC;AAExD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,cAAc;IACzB,uCAAuC;;IAEvC,0BAA0B;;;;;;;;;IAE1B;gDAC4C;;;;;;;;;;;;;;;IAE5C,kEAAkE;;;;;;;;;IAElE,iDAAiD;;;;;;;;;;;;;;;;;;IAEjD,8BAA8B;;;;;;;;;;;;;;IAE9B;uCACmC;;EAEnC,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAC;AAEnD,MAAM,MAAM,UAAU,GAAG,WAAW,CAAC,OAAO,cAAc,CAAC,CAAC;AAI5D;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU,CAc7D"}