@elaraai/e3 1.0.79 → 1.0.80

package/dist/src/task.d.ts

@@ -5,13 +5,16 @@
 /**
  * Task definitions for e3 packages.
  *
- * Tasks are organized under `.tasks.${name}` with:
- * - `.tasks.${name}.function_ir` - The compiled IR (private)
- * - `.tasks.${name}.output` - The output dataset (public)
+ * A task reads datasets and writes one output, the dataset at
+ * `.tasks.${name}.output`: {@link task} returns it, {@link streamTask} emits
+ * it into an output kind, and {@link customTask} runs a command that writes
+ * it. The program a task runs is named by the task object export writes, not
+ * held in the data tree.
  */
-import type { AsyncFunctionExpr, BlockBuilder, CallableAsyncFunctionExpr, CallableFunctionExpr, DictType, EastType, ExprType, FunctionExpr, NeverType, SetType, SubtypeExprOrValue } from '@elaraai/east';
-import { Expr, variant, ArrayType, StringType, NullType, FunctionType, StructType } from '@elaraai/east';
-import type { DatasetDef, DataTreeDef, TaskDef } from './types.js';
+import type { AsyncFunctionExpr, BlockBuilder, CallableAsyncFunctionExpr, CallableFunctionExpr, EastType, ExprType, FunctionExpr } from '@elaraai/east';
+import { Expr, variant, ArrayType, StringType, NullType } from '@elaraai/east';
+import type { TaskRole } from '@elaraai/e3-types';
+import type { DatasetDef, DataTreeDef, OutputDef, PartitionDef, TaskDef } from './types.js';
 import { type Runner } from './runner.js';
 import { type EnvironmentDecl } from './environment.js';
 /**
@@ -21,6 +24,8 @@ import { type EnvironmentDecl } from './environment.js';
 type ExtractDatasetTypes<T extends readonly DatasetDef[]> = {
     [K in keyof T]: T[K] extends DatasetDef<infer U> ? U : never;
 } & EastType[];
+/** The task-output path tuple for task `Name`. */
+type TaskOutputPath<Name extends string> = [variant<'field', 'tasks'>, variant<'field', Name>, variant<'field', 'output'>];
 /**
  * Singleton tree definition for `.tasks`.
  *
@@ -31,10 +36,11 @@ export declare const tasksTree: DataTreeDef;
  * Defines a task that runs an East function to produce an output dataset.
  *
  * Tasks read from input datasets and produce an output dataset.
- * When input datasets change, the task re-runs automatically.
+ * When input datasets change, the task re-runs automatically. The function
+ * runs once, as one unit: a large input opens lazily, and a collection it
+ * returns is written segment by segment.
  *
  * Task structure:
- * - `.tasks.${name}.function_ir` - The compiled IR (private)
  * - `.tasks.${name}.output` - The output dataset
  *
  * @typeParam Name - Task name (literal type)
@@ -43,8 +49,15 @@ export declare const tasksTree: DataTreeDef;
  * @param name - Task name
  * @param inputs - Input datasets to read from
  * @param fn - Implementation function
+ * @param config - The runner the function runs on (default
+ *   {@link DEFAULT_RUNNER}), the environment it runs in, and its role: a data
+ *   task (the default), or a UI task with the data its surface reads
  * @returns A TaskDef with `.output` for chaining
+ * @throws {Error} When an input is marked with `e3.partition`, which only
+ *   {@link streamTask} takes.
  *
+ * @see {@link streamTask} for an output emitted instead of returned, and work
+ * split over an input.
  * @see {@link customTask} for defining tasks with custom command logic (e.g. performing non-East operations).
  *
  * @example
@@ -67,281 +80,133 @@ export declare const tasksTree: DataTreeDef;
  */
 export declare function task<Name extends string, Inputs extends readonly DatasetDef[], Output extends EastType>(name: Name, inputs: [...Inputs], fn: FunctionExpr<ExtractDatasetTypes<Inputs>, Output> | CallableFunctionExpr<ExtractDatasetTypes<Inputs>, Output> | AsyncFunctionExpr<ExtractDatasetTypes<Inputs>, Output> | CallableAsyncFunctionExpr<ExtractDatasetTypes<Inputs>, Output>, config?: {
     runner?: Runner;
-    kind?: string;
-    metadata?: Uint8Array;
-    environment?: EnvironmentDecl;
-}): TaskDef<Output, [variant<'field', 'tasks'>, variant<'field', Name>, variant<'field', 'output'>]>;
-export declare function customTask<Name extends string, Inputs extends Array<DatasetDef>, Output extends EastType>(name: Name, inputs: Inputs, outputType: Output, command: ($: BlockBuilder<StringType>, input_paths: ExprType<ArrayType<StringType>>, output_path: ExprType<StringType>) => Expr<StringType> | void, config?: {
     environment?: EnvironmentDecl;
-}): TaskDef<Output, [variant<'field', 'tasks'>, variant<'field', Name>, variant<'field', 'output'>]>;
-/** The task-output path tuple for task `Name`. */
-type TaskOutputPath<Name extends string> = [variant<'field', 'tasks'>, variant<'field', Name>, variant<'field', 'output'>];
-/** The expression parameters a body callback receives for a dataset tuple. */
-type DatasetExprs<T extends readonly DatasetDef[]> = {
-    [K in keyof T]: T[K] extends DatasetDef<infer U> ? ExprType<U> : never;
-};
-/** The key type a partitioned collection is carved by: Dict keys, Set
- *  elements, or Array elements. */
-type CollectionKeyType<T> = T extends DictType<infer K, any> ? K : T extends SetType<infer E> ? E : T extends ArrayType<infer E> ? E : never;
-/** The per-dataset key types of a partition tuple. */
-type PartitionKeyTypes<Ps extends readonly DatasetDef[]> = {
-    [K in keyof Ps]: Ps[K] extends DatasetDef<infer T> ? CollectionKeyType<T> : never;
-};
-/** Field-wise intersection of two key types: for struct keys, the fields
- *  present in both with the identical East type; otherwise the types must
- *  agree exactly. */
-type IntersectKeys<A, B> = A extends StructType<infer FA> ? B extends StructType<infer FB> ? StructType<{
-    [F in keyof FA & keyof FB as FA[F] extends FB[F] ? (FB[F] extends FA[F] ? F : never) : never]: FA[F];
-}> : never : A extends B ? (B extends A ? A : never) : never;
-/** The strict field-wise intersection of every partitioned dataset's key
- *  type — what a co-partitioned `by` projection receives. */
-type PartitionByKey<Ps extends readonly DatasetDef[]> = PartitionKeyTypes<Ps> extends readonly [infer Only] ? Only : PartitionKeyTypes<Ps> extends readonly [infer A, ...infer Rest] ? IntersectKeysAll<A, Rest> : never;
-/** Folds {@link IntersectKeys} over the remaining key types. */
-type IntersectKeysAll<A, Rest> = Rest extends readonly [] ? A : Rest extends readonly [infer B, ...infer More] ? IntersectKeysAll<IntersectKeys<A, B>, More> : never;
-/** What a `by` projection may return: an expression over the key (the
- *  identity, a field read, or a nested path — leading-prefix ORDER is
- *  validated at build time, since TypeScript types carry no field order), or
- *  a struct literal drawn from the key's own fields with their own
- *  expression types. Anything else is a type error at the call site. */
-type ByResult<K> = Expr<any> | (K extends StructType<infer F> ? {
-    [P in keyof F]?: ExprType<F[P]>;
-} : never);
-/** What `merge` takes for a keyed output: a Dict output folds the values of
- *  equal keys with a function of the key and two values, a Set output
- *  collapses equal elements with the literal `'union'`, and no other output
- *  takes one. */
-type OutputMerge<Output extends EastType> = Output extends DictType<infer K, infer V> ? ($: BlockBuilder<V>, key: ExprType<K>, a: ExprType<V>, b: ExprType<V>) => SubtypeExprOrValue<V> | void : Output extends SetType<any> ? 'union' : never;
+    role?: TaskRole;
+}): TaskDef<Output, TaskOutputPath<Name>>;
 /**
- * The declaration half of {@link partitionTask} — everything structural about
- * the task; the body comes last as the `fn` argument.
+ * Defines a task that runs a command rather than East: a bash script built
+ * from the staged input paths and the path the output must be written to.
  *
- * @typeParam Partitions - The partitioned (huge, co-partitioned) input datasets
- * @typeParam Inputs - The ordinary input datasets
- * @typeParam Output - The output dataset's East type
+ * @typeParam Name - Task name (literal type)
+ * @typeParam Inputs - Input dataset types
+ * @typeParam Output - Output type
+ * @param name - Task name
+ * @param inputs - Input datasets, staged as beast2 files
+ * @param outputType - The East type of the beast2 file the command writes
+ * @param command - Builds the bash script from the input paths and the output path
+ * @param config - The environment the command runs in
+ * @returns A TaskDef with `.output` for chaining
  */
-export interface PartitionTaskSpec<Partitions extends readonly [DatasetDef, ...DatasetDef[]], Inputs extends readonly DatasetDef[], Output extends EastType> {
-    /** One or more huge collection inputs, carved into shared key-range
-     *  partitions. Two or more entries co-partition: all must be Dict or all
-     *  Set roots with a shared key space. */
-    readonly partitions: [...Partitions];
-    /** Boundary-alignment projection: rows with equal `by(key)` never split
-     *  across partitions. Must read a leading prefix of every partitioned
-     *  dataset's key, so aligned runs stay contiguous in canonical order.
-     *  Accepted shapes (validated at build time): the key itself; a leading
-     *  field (`key.f`); a nested leading-field path (`key.a.b`, each step the
-     *  first field of its level); or a struct literal of leading fields in
-     *  declared order (`{ f1: key.f1, f2: key.f2 }`). Any other body is
-     *  rejected at build time — semantically monotone projections outside
-     *  these shapes are deliberately not inferred. The return type admits
-     *  only expressions over the key or a struct literal of the key's own
-     *  fields ({@link ByResult}); field ORDER is the build-time half. */
-    readonly by?: ($: BlockBuilder<NeverType>, key: ExprType<PartitionByKey<Partitions>>) => ByResult<PartitionByKey<Partitions>>;
-    /** Ordinary inputs, passed whole to every partition execution (small ⇒
-     *  broadcast; huge + indexed ⇒ opened lazily by the runner). Any change to
-     *  them re-runs all partitions. */
-    readonly inputs?: [...Inputs];
-    /** The output dataset's East type. */
-    readonly output: Output;
-    /** Associative fold merging two partials into one. When present, each
-     *  partition execution returns a partial of the output and partials fold
-     *  pairwise in a fixed tree order; when absent, each execution returns its
-     *  shard of the output and the shards splice in partition order. */
-    readonly combine?: ($: BlockBuilder<Output>, a: ExprType<Output>, b: ExprType<Output>) => SubtypeExprOrValue<Output> | void;
-    /**
-     * Per-key resolution for keyed partials that may collide — the third
-     * assembly mode, alongside splice and `combine`.
-     *
-     * @remarks
-     * The partials are merged by the task's runner — its `merge` command, over
-     * sorted partials, in one pass; the orchestrator never decodes them.
-     * Partials whose key ranges overlap are grouped, and each group merges
-     * through a tree of merge executions (up to 32 partials each) folding equal
-     * keys in partition order; partials no other partial reaches take no merge
-     * at all, and the results splice. Every merge unit is an ordinary cached
-     * execution: a re-run with unchanged partials merges nothing again, and the
-     * intermediate results of the tree are stored like any other execution
-     * output. The merge command is built here, at export, and carried in the
-     * package's metadata like any other command IR.
-     *
-     * A `Dict` output takes a function of the key and two of its values, over
-     * the output's own key and value types; a `Set` output takes the literal
-     * `'union'`. The function must be associative — a key's values may fold in
-     * any grouping, though never out of partition order. Mutually exclusive with
-     * {@link combine}, which stays the mode for non-collection outputs (KPIs,
-     * counts) and for authors who want a whole-value fold.
-     *
-     * Needs a stock runtime: the merge units run the runner's `merge` command,
-     * which the `custom` runtime does not have and an older runner does not
-     * ship.
-     */
-    readonly merge?: OutputMerge<Output>;
-    /** Target carved-slice size in wire bytes. Defaults to 256 MiB. */
-    readonly targetPartitionBytes?: number;
-    /** Runtime the body runs on; defaults to {@link DEFAULT_RUNNER}. */
-    readonly runner?: Runner;
-    /** Execution environment declaration, as for {@link task}. */
-    readonly environment?: EnvironmentDecl;
-}
+export declare function customTask<Name extends string, Inputs extends Array<DatasetDef>, Output extends EastType>(name: Name, inputs: Inputs, outputType: Output, command: ($: BlockBuilder<StringType>, input_paths: ExprType<ArrayType<StringType>>, output_path: ExprType<StringType>) => Expr<StringType> | void, config?: {
+    environment?: EnvironmentDecl;
+}): TaskDef<Output, TaskOutputPath<Name>>;
 /**
- * Defines a partitioned task: e3 carves the huge partitioned input(s) into
- * key-range slices, runs `fn` once per partition as an ordinary
- * content-addressed execution (parallel, memoized per partition), and
- * assembles the output — by splicing shards in partition order, by merging
- * keyed partials on the task's runner when `merge` is given, or by folding
- * partials pairwise when `combine` is given.
+ * Marks an input of a {@link streamTask} as one its work may be split over.
  *
- * `fn` always returns the output type: without `combine` each execution
- * returns its *shard* of the output (Array shards concatenate freely;
- * Dict/Set shard key ranges must ascend disjointly in partition order — any
- * key-preserving or monotone re-keying transform qualifies). The shard
- * contract is deliberately enforced at SPLICE TIME, not build time: whether
- * an arbitrary body preserves key order is not decidable from types, and a
- * static rule would false-reject permitted monotone re-keys — a violation
- * fails the task deterministically at splice, naming the offending
- * partitions and the remedies (`combine` / `customTask`). With `combine`
- * each execution returns a *partial* and the partials fold.
+ * The body receives one piece of the dataset, typed as the whole: a key range
+ * of a Set or Dict, or a position range of an Array. Pieces are cut where the
+ * content says, so an insertion re-cuts only the pieces around it. Rows whose
+ * `by` fields are equal are never split across pieces.
  *
- * Parameter order is fixed and fully typed: the partition slices first (in
- * declared order, each typed as its dataset's own collection type), then the
- * ordinary `inputs` in order.
+ * `by` names leading key fields, in order — `['account']`, or
+ * `['account', 'at.day']`, whose last entry reads the first field of `at`. Two
+ * or more partitioned inputs are cut at the same keys, so they must be Sets or
+ * Dicts whose keys, or whose `by` fields, have the same types. {@link
+ * streamTask} checks all of this against the dataset, naming the task.
  *
- * @typeParam Name - Task name (literal type)
- * @typeParam Partitions - Partitioned input dataset defs
- * @typeParam Inputs - Ordinary input dataset defs
- * @typeParam Output - Output type
- * @param name - Task name
- * @param spec - The declaration: partitioned inputs, alignment, output type,
- *   combine mode, sizing, runner and environment
- * @param fn - Implementation body, run once per partition
- * @returns A TaskDef with `.output` for chaining
- * @throws {Error} When a partitioned dataset is not a collection, partitions
- *   mix collection kinds (or include Arrays) under co-partitioning, key
- *   types cannot align, `by` (explicit or the implicit alignment under
- *   co-partitioning) does not read a leading prefix of every partitioned
- *   dataset's key, the output is not a collection in splice mode (no
- *   `combine`), or `merge` is given alongside `combine`, on an Array output,
- *   in the wrong form for the output's kind, or with the `custom` runtime.
+ * @typeParam T - The dataset's East type
+ * @param dataset - The dataset
+ * @param config - `by`, the fields rows are grouped by
+ * @returns The marked input, to pass in a stream task's `inputs`
  *
  * @example
  * ```ts
- * const sales = e3.input('sales', DictType(StringType, SaleType));
- *
- * const cleaned = e3.partitionTask('cleaned', {
- *   partitions: [sales],
- *   output: DictType(StringType, SaleType),
- * }, ($, slice) => slice.filter(($, sale) => East.greater(sale.qty, 0n)));
+ * const totals = e3.streamTask('totals', {
+ *   inputs: [e3.partition(sales, { by: ['account'] }), rates],
+ *   output: e3.output.dict(StringType, FloatType, { merge: ($, account, a, b) => a.add(b) }),
+ * }, ($, sales, rates, emit) => {
+ *   $.for(sales, ($, sale, key) => {
+ *     $(emit(key.account, sale.amount.multiply(rates.get(sale.currency))));
+ *   });
+ * });
  * ```
  */
-export declare function partitionTask<Name extends string, const Partitions extends readonly [DatasetDef, ...DatasetDef[]], const Inputs extends readonly DatasetDef[] = [], Output extends EastType = EastType>(name: Name, spec: PartitionTaskSpec<Partitions, Inputs, Output>, fn: ($: BlockBuilder<Output>, ...args: [...DatasetExprs<Partitions>, ...DatasetExprs<Inputs>]) => SubtypeExprOrValue<Output> | void): TaskDef<Output, TaskOutputPath<Name>>;
-/** The `emit` capability's function type for an output collection: Dict
- *  outputs emit `(key, value)`, Array/Set outputs emit `(element)`. */
-export type EmitOf<Out extends EastType> = Out extends DictType<infer K, infer V> ? FunctionType<[K, V], NullType> : Out extends SetType<infer E> ? FunctionType<[E], NullType> : Out extends ArrayType<infer E> ? FunctionType<[E], NullType> : never;
+export declare function partition<T extends EastType>(dataset: DatasetDef<T>, config?: {
+    by?: string[];
+}): PartitionDef<T>;
+/** The expression a stream task's body receives for each input. */
+type InputExprs<T extends readonly (DatasetDef | PartitionDef)[]> = {
+    [K in keyof T]: T[K] extends PartitionDef<infer U> ? ExprType<U> : T[K] extends DatasetDef<infer U> ? ExprType<U> : never;
+};
 /**
- * The declaration half of {@link streamTask} — everything structural about
- * the task; the body comes last as the `fn` argument.
+ * The declaration half of {@link streamTask}; the body comes last as the `fn`
+ * argument.
  *
- * @typeParam Stream - The streamed input dataset def, when present
- * @typeParam Inputs - The ordinary input datasets
- * @typeParam Output - The output collection's East type
+ * @typeParam Inputs - The inputs, some marked with {@link partition}
+ * @typeParam Output - The output kind
  */
-export interface StreamTaskSpec<Stream extends DatasetDef | undefined, Inputs extends readonly DatasetDef[], Output extends EastType> {
-    /** The input the runner feeds through the body in canonical order with
-     *  O(segment) memory. Omit entirely for a producer task (the body loops
-     *  over platform-function sources and emits). */
-    readonly stream?: Stream;
-    /** Ordinary inputs, decoded whole. */
-    readonly inputs?: [...Inputs];
-    /** The output collection type. An Array output stores its elements in
-     *  emission order. A Set or Dict output must be emitted in ascending key
-     *  order (East's total order): the runner writes it in one pass, segment by
-     *  segment, and an out-of-order key fails the task with the same message
-     *  on every runtime. Duplicate Set/Dict keys are a runtime error unless
-     *  {@link merge} folds them. */
+export interface StreamTaskSpec<Inputs extends readonly (DatasetDef | PartitionDef)[], Output extends OutputDef> {
+    /** The inputs, in the body's parameter order. An input wrapped in
+     *  {@link partition} is one the work may be split over; the others reach
+     *  every piece whole, opened lazily when large. Empty for a producer. */
+    readonly inputs: [...Inputs];
+    /** The output kind — `e3.output.array`, `set`, `dict` or `fold`. It fixes
+     *  `emit`'s signature and how the parts of the output combine. */
     readonly output: Output;
-    /**
-     * How the runner's sink folds emissions with equal keys that arrive
-     * together, instead of failing on the duplicate.
-     *
-     * @remarks
-     * A `Dict` output takes a function of the key and two values: adjacent
-     * equal keys fold left in emission order, `acc = merge(key, acc, value)`. A
-     * `Set` output takes the literal `'union'`: adjacent equal elements collapse
-     * to the first. The ascending contract stands — `merge` folds the equal keys
-     * of a grouped stream; keys that collide across the stream are a
-     * `partitionTask` with `merge`. The stored dataset is exactly the output the
-     * folded emissions would write. An Array output takes no `merge`.
-     */
-    readonly merge?: OutputMerge<Output>;
-    /** Runtime the body runs on; defaults to {@link DEFAULT_RUNNER}. Every
-     *  stock runtime streams the output through `emit` and feeds the `stream`
-     *  input lazily (segment-fed iteration and keyed reads at O(segment)
-     *  decoded memory; any other operation on it decodes the whole value
-     *  once). The `custom` runtime is rejected — its argv cannot carry the
-     *  streaming flags. */
+    /** Runtime the body runs on; defaults to {@link DEFAULT_RUNNER}. A stock
+     *  runtime: the `custom` one runs only a program that returns its output. */
     readonly runner?: Runner;
     /** Execution environment declaration, as for {@link task}. */
     readonly environment?: EnvironmentDecl;
 }
-/** The body parameters of a {@link streamTask}: the stream value when
- *  declared, the ordinary inputs, then the `emit` capability. */
-type StreamTaskArgs<Stream extends DatasetDef | undefined, Inputs extends readonly DatasetDef[], Output extends EastType> = Stream extends DatasetDef<infer S> ? [ExprType<S>, ...DatasetExprs<Inputs>, ExprType<EmitOf<Output>>] : [...DatasetExprs<Inputs>, ExprType<EmitOf<Output>>];
 /**
- * Defines a streaming task: one execution whose runner feeds the `stream`
- * input segment-by-segment in canonical order (state is ordinary `$.let`
- * locals) and writes the output incrementally through the `emit` capability
- * — bounded memory at both ends, exact left-fold semantics, no parallelism
- * and no partial recompute.
- *
- * `emit` is a runner-implemented function value: `emit(key, value)` for Dict
- * outputs, `emit(element)` for Array/Set outputs. The streaming writer
- * re-batches emissions byte-adaptively and writes the output in one pass,
- * with one open batch in memory whatever the output's size. An Array output
- * takes its elements in emission order; a Set or Dict output must be emitted
- * in ascending key order, and an out-of-order key fails the task (`beast2
- * v5: Dict key emitted out of order: 1 after 2 — Set/Dict emissions must
- * ascend in East order`, the same words on every runtime). A re-key whose
- * output keys do not arrive in order is a `partitionTask` with `merge`.
- * Duplicate Set/Dict keys are a runtime error unless `merge` folds them: a
- * function for a Dict output (adjacent equal keys fold left in emission
- * order), `'union'` for a Set output. The body's return value is unused —
- * the output dataset is what `emit` wrote.
- *
- * With no `stream`, the task is a producer: its body loops over
- * platform-function sources (paginated APIs, database cursors) and emits.
- * A producer's real input is the outside world, so it follows the existing
- * integration-task conventions for re-run semantics — `emit` changes nothing
- * about that.
+ * Defines a stream task: a body that emits its output into an output kind
+ * rather than returning it, over inputs its work may be split across.
+ *
+ * `emit` is the body's trailing parameter, and the output kind fixes its
+ * signature: `emit(t)` for `array`, `set` and `fold`, `emit(k, v)` for
+ * `dict`. Emission order is free — the platform sorts sets and dicts — and
+ * the parts of the output combine as the kind says: concatenated for an
+ * array, united for a set, by key for a dict (equal keys folding with its
+ * `merge`), and folded with `combine` from `zero` for a fold.
+ *
+ * An input wrapped in {@link partition} is one the work may be split over:
+ * the body runs once per piece, each piece typed as the whole dataset, and
+ * the pieces' outputs combine by the output kind. The other inputs reach
+ * every piece whole. With no partitioned input the task is one unit, with
+ * exact left-to-right semantics; a producer has no inputs at all, and emits
+ * what it reads from platform functions.
+ *
+ * The author's contract, the only one: `merge` and `combine` are associative,
+ * `zero` is an identity of `combine`, and a partitioned body's combined
+ * result does not depend on where its input was cut.
  *
  * @typeParam Name - Task name (literal type)
- * @typeParam Output - Output collection type
- * @typeParam Stream - Streamed input dataset def, when present
- * @typeParam Inputs - Ordinary input dataset defs
+ * @typeParam Inputs - The inputs, some marked with {@link partition}
+ * @typeParam Output - The output kind
  * @param name - Task name
- * @param spec - The declaration: stream input, ordinary inputs, output
- *   collection type, merge, runner and environment
- * @param fn - Implementation body; receives the stream value (when
- *   declared), the inputs, then `emit`, and returns nothing
+ * @param spec - The inputs, the output kind, the runner and the environment
+ * @param fn - The body; receives the inputs, then `emit`, and returns nothing
  * @returns A TaskDef with `.output` for chaining
- * @throws {Error} When the output is not a collection type, the runner is
- *   the `custom` runtime, or `merge` is given for an Array output or in the
- *   wrong form for the output's kind.
+ * @throws {Error} When the output is not an output kind, the runner is the
+ *   `custom` runtime, a partitioned input is not a collection, a `by` names
+ *   something other than leading key fields, or co-partitioned inputs have no
+ *   common key.
  *
  * @example
  * ```ts
- * const events = e3.input('events', ArrayType(EventType));
- *
- * const balances = e3.streamTask('balances', {
- *   stream: events,
- *   output: ArrayType(BalanceType),
- * }, ($, events, emit) => {
- *   const balance = $.let(0.0);
- *   $.for(events, ($, event) => {
- *     $.assign(balance, balance.add(event.amount));
- *     $(emit({ at: event.at, balance }));
+ * const sales = e3.input('sales', DictType(SaleKeyType, SaleType));
+ *
+ * const byAccount = e3.streamTask('by_account', {
+ *   inputs: [e3.partition(sales)],
+ *   output: e3.output.dict(StringType, FloatType, { merge: ($, account, a, b) => a.add(b) }),
+ * }, ($, sales, emit) => {
+ *   $.for(sales, ($, sale) => {
+ *     $(emit(sale.account, sale.amount));
  *   });
  * });
  * ```
  */
-export declare function streamTask<Name extends string, Output extends EastType, const Stream extends DatasetDef | undefined = undefined, const Inputs extends readonly DatasetDef[] = []>(name: Name, spec: StreamTaskSpec<Stream, Inputs, Output>, fn: ($: BlockBuilder<NullType>, ...args: StreamTaskArgs<Stream, Inputs, Output>) => void): TaskDef<Output, TaskOutputPath<Name>>;
+export declare function streamTask<Name extends string, const Inputs extends readonly (DatasetDef | PartitionDef)[], Output extends OutputDef>(name: Name, spec: StreamTaskSpec<Inputs, Output>, fn: ($: BlockBuilder<NullType>, ...args: [...InputExprs<Inputs>, ExprType<Output['emit']>]) => void): TaskDef<Output['type'], TaskOutputPath<Name>>;
 export {};
 //# 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":"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"}