@elaraai/e3-types 1.0.77 → 1.0.79

package/dist/src/stream.js

@@ -0,0 +1,134 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * The stream and merge commands (issue #770) — the builders of every argv a
+ * stream execution spawns (an authored `streamTask`'s) and of the merge
+ * command a partitioned task's keyed fan-in runs per key range, both built
+ * at export time and carried in the package like any other command IR.
+ */
+import { ArrayType, East, StringType } from '@elaraai/east';
+import { runnerToArgv } from './runner.js';
+/**
+ * Builds the command IR of a stream execution: `(input_paths, output_path)
+ * -> argv`.
+ *
+ * The argv is `[...runner, '--emit', <emit>, '--merge' <merge IR path> |
+ * '--union', '--stream' '0' when the first -i input streams, '-i' <path> for
+ * each -i input, '-o', <output>, <body IR path>]` — the body IR is wire
+ * input 0, the merge IR wire input 1 in function mode, and the `-i` inputs
+ * follow. Built with `East.function` exactly as a task command is.
+ *
+ * @param runner - the stock runner the execution spawns
+ * @param spec - the emit kind, the merge mode and the streamed input
+ * @returns the command IR
+ *
+ * @example
+ * ```ts
+ * import { variant } from '@elaraai/east';
+ *
+ * const command = streamCommandIr(variant('east_c', { platforms: [] }), { emit: 'dict', merge: 'function', stream: 'first' });
+ * command.compile([])(['body.beast2', 'merge.beast2', 'a.beast2'], 'out.beast2');
+ * // ['east-c', 'run', '--emit', 'dict', '--merge', 'merge.beast2', '--stream', '0',
+ * //  '-i', 'a.beast2', '-o', 'out.beast2', 'body.beast2']
+ * ```
+ */
+export function streamCommandIr(runner, spec) {
+    const prefix = [
+        ...runnerToArgv(runner),
+        '--emit', spec.emit,
+        ...(spec.merge === 'union' ? ['--union'] : []),
+    ];
+    // The merge mode and the streamed input are known here, so the flags they
+    // add are emitted by branching at build time — only the merge IR's PATH is
+    // a run-time value, and only the -i inputs need a loop.
+    const mergeInput = spec.merge === 'function' ? 1n : null;
+    const firstInput = mergeInput === null ? 1n : 2n;
+    const command = East.function([ArrayType(StringType), StringType], ArrayType(StringType), ($, input_paths, output_path) => {
+        const argv = $.let(prefix, ArrayType(StringType));
+        if (mergeInput !== null) {
+            $(argv.pushLast('--merge'));
+            $(argv.pushLast(input_paths.get(mergeInput)));
+        }
+        if (spec.stream === 'first') {
+            $(argv.pushLast('--stream'));
+            $(argv.pushLast('0'));
+        }
+        const i = $.let(firstInput);
+        $.while(East.less(i, input_paths.size()), $ => {
+            $(argv.pushLast('-i'));
+            $(argv.pushLast(input_paths.get(i)));
+            $.assign(i, i.add(1n));
+        });
+        $(argv.pushLast('-o'));
+        $(argv.pushLast(output_path));
+        $(argv.pushLast(input_paths.get(0n)));
+        $.return(argv);
+    });
+    return command.toIR();
+}
+/**
+ * Builds the command IR of a merge execution — the runner's `merge` command
+ * over sorted partials of one Set or Dict type, within a key range:
+ * `(input_paths, output_path) -> argv`.
+ *
+ * The argv is `[...runner merge, '--merge' <merge IR path> | '--union',
+ * '--range' <range path>, '-i' <path> for each partial, '-o', <output>]`. In
+ * `function` mode wire input 0 is the merge IR `(K, V, V) -> V`, wire input
+ * 1 the key range and the partials follow; in `union` mode wire input 0 is
+ * the key range and every other wire input is a partial. The key range is a
+ * blob of `Struct{from: Option<K>, to: Option<K>}` over the output's key
+ * type: only the keys in `[from, to)` merge, each partial sought to the
+ * segment owning `from`, and an absent bound is open — a component that
+ * merges whole takes the open range. Equal keys across partials fold in
+ * input order, and the output is byte-identical to what the runner's emit
+ * sink writes for the same entries emitted ascending. A partitioned task's
+ * SDK writes this IR into its metadata at export, and the orchestrator runs
+ * it as an ordinary execution per key range of a group of partials.
+ *
+ * @param runner - the stock runner whose `merge` command runs
+ * @param mode - `function` (a Dict output, folded with the merge IR) or
+ *   `union` (a Set output, the first of equal elements standing)
+ * @returns the command IR
+ * @throws {Error} When the runner is `custom` — it has no merge command.
+ *
+ * @example
+ * ```ts
+ * import { variant } from '@elaraai/east';
+ *
+ * const command = mergeCommandIr(variant('east_c', { platforms: [] }), 'function');
+ * command.compile([])(['merge.beast2', 'range.beast2', 'p0.beast2', 'p1.beast2'], 'out.beast2');
+ * // ['east-c', 'merge', '--merge', 'merge.beast2', '--range', 'range.beast2',
+ * //  '-i', 'p0.beast2', '-i', 'p1.beast2', '-o', 'out.beast2']
+ * ```
+ */
+export function mergeCommandIr(runner, mode) {
+    const prefix = [
+        ...runnerToArgv(runner, 'merge'),
+        ...(mode === 'union' ? ['--union'] : []),
+    ];
+    const mergeInput = mode === 'function' ? 0n : null;
+    const rangeInput = mergeInput === null ? 0n : 1n;
+    const firstInput = rangeInput + 1n;
+    const command = East.function([ArrayType(StringType), StringType], ArrayType(StringType), ($, input_paths, output_path) => {
+        const argv = $.let(prefix, ArrayType(StringType));
+        if (mergeInput !== null) {
+            $(argv.pushLast('--merge'));
+            $(argv.pushLast(input_paths.get(mergeInput)));
+        }
+        $(argv.pushLast('--range'));
+        $(argv.pushLast(input_paths.get(rangeInput)));
+        const i = $.let(firstInput);
+        $.while(East.less(i, input_paths.size()), $ => {
+            $(argv.pushLast('-i'));
+            $(argv.pushLast(input_paths.get(i)));
+            $.assign(i, i.add(1n));
+        });
+        $(argv.pushLast('-o'));
+        $(argv.pushLast(output_path));
+        $.return(argv);
+    });
+    return command.toIR();
+}
+//# sourceMappingURL=stream.js.map

package/dist/src/stream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.js","sourceRoot":"","sources":["../../src/stream.ts"],"names":[],"mappings":"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"}

package/dist/src/stream.spec.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+export {};
+//# sourceMappingURL=stream.spec.d.ts.map

package/dist/src/stream.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.spec.d.ts","sourceRoot":"","sources":["../../src/stream.spec.ts"],"names":[],"mappings":"AAAA;;;GAGG"}

package/dist/src/stream.spec.js

@@ -0,0 +1,60 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * The stream and merge command builders (issue #770): the argv a stream
+ * execution spawns for each merge mode and streamed-input choice, and the
+ * argv a merge execution spawns over sorted partials within a key range.
+ */
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { variant } from '@elaraai/east';
+import { mergeCommandIr, streamCommandIr } from './stream.js';
+const EAST_C = variant('east_c', { platforms: ['east-c-std'] });
+/** The argv a stream command evaluates to for the staged `inputs`. */
+function argvOf(runner, spec, inputs) {
+    return streamCommandIr(runner, spec).compile([])(inputs, 'out.beast2');
+}
+/** The argv a merge command evaluates to for the staged `inputs`. */
+function mergeArgvOf(runner, mode, inputs) {
+    return mergeCommandIr(runner, mode).compile([])(inputs, 'out.beast2');
+}
+describe('streamCommandIr', () => {
+    it('builds a folding dict argv: the merge IR as --merge, the first input streamed', () => {
+        assert.deepEqual(argvOf(EAST_C, { emit: 'dict', merge: 'function', stream: 'first' }, ['body.beast2', 'merge.beast2', 'rows.beast2', 'other.beast2']), ['east-c', 'run', '-p', 'east-c-std', '--emit', 'dict', '--merge', 'merge.beast2', '--stream', '0',
+            '-i', 'rows.beast2', '-i', 'other.beast2', '-o', 'out.beast2', 'body.beast2']);
+    });
+    it('builds a union set argv streaming the first input', () => {
+        assert.deepEqual(argvOf(EAST_C, { emit: 'set', merge: 'union', stream: 'first' }, ['body.beast2', 'stream.beast2', 'other.beast2']), ['east-c', 'run', '-p', 'east-c-std', '--emit', 'set', '--union', '--stream', '0',
+            '-i', 'stream.beast2', '-i', 'other.beast2', '-o', 'out.beast2', 'body.beast2']);
+    });
+    it('builds a producer argv with no merge flag and no streamed input', () => {
+        assert.deepEqual(argvOf(EAST_C, { emit: 'array', merge: 'none', stream: 'none' }, ['body.beast2', 'config.beast2']), ['east-c', 'run', '-p', 'east-c-std', '--emit', 'array', '-i', 'config.beast2', '-o', 'out.beast2', 'body.beast2']);
+    });
+    it('starts from the runner argv of every stock runtime', () => {
+        const node = variant('east_node', { platforms: ['@elaraai/east-node-std'] });
+        const argv = argvOf(node, { emit: 'set', merge: 'none', stream: 'first' }, ['body.beast2', 'rows.beast2']);
+        assert.deepEqual(argv.slice(0, 6), ['east-node', 'run', '-p', '@elaraai/east-node-std', '--emit', 'set']);
+    });
+});
+describe('mergeCommandIr', () => {
+    it('builds a dict merge argv: the merge IR as --merge, the key range as --range, every other input a partial', () => {
+        assert.deepEqual(mergeArgvOf(EAST_C, 'function', ['merge.beast2', 'range.beast2', 'p0.beast2', 'p1.beast2', 'p2.beast2']), ['east-c', 'merge', '-p', 'east-c-std', '--merge', 'merge.beast2', '--range', 'range.beast2',
+            '-i', 'p0.beast2', '-i', 'p1.beast2', '-i', 'p2.beast2', '-o', 'out.beast2']);
+    });
+    it('builds a set union argv: the key range first, every other input a partial', () => {
+        assert.deepEqual(mergeArgvOf(EAST_C, 'union', ['range.beast2', 'p0.beast2', 'p1.beast2']), ['east-c', 'merge', '-p', 'east-c-std', '--union', '--range', 'range.beast2', '-i', 'p0.beast2', '-i', 'p1.beast2', '-o', 'out.beast2']);
+    });
+    it('runs the merge command of every stock runtime', () => {
+        const py = variant('east_py', { platforms: ['east-py-std'] });
+        assert.deepEqual(mergeArgvOf(py, 'union', ['range.beast2', 'p0.beast2']).slice(0, 4), ['east-py', 'merge', '-p', 'east-py-std']);
+        const node = variant('east_node', { platforms: [] });
+        assert.deepEqual(mergeArgvOf(node, 'function', ['merge.beast2', 'range.beast2', 'p0.beast2']).slice(0, 2), ['east-node', 'merge']);
+    });
+    it('refuses a custom runner, which has no merge command', () => {
+        const custom = variant('custom', { command: ['uv', 'run', 'east-py', 'run'] });
+        assert.throws(() => mergeCommandIr(custom, 'union'), { message: 'a custom runner has no merge command' });
+    });
+});
+//# sourceMappingURL=stream.spec.js.map

package/dist/src/stream.spec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.spec.js","sourceRoot":"","sources":["../../src/stream.spec.ts"],"names":[],"mappings":"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"}

package/dist/src/task.d.ts

@@ -15,6 +15,7 @@
  * specified paths - the task just references locations, not types.
  */
 import { StructType, StringType, ArrayType, BlobType, BooleanType, IntegerType, OptionType, ValueTypeOf } from '@elaraai/east';
+import type { EastTypeValue, FunctionIR } from '@elaraai/east';
 /**
  * Task object stored in the object store.
  *
@@ -116,6 +117,13 @@ export declare const TASK_KIND_PARTITION = "partition";
  *  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.
  *
@@ -146,17 +154,29 @@ export declare const PartitionTaskMetadataType: StructType<{
      * `encodeEastIR` bundle of the per-key merge `(Key, Value, Value) -> Value`
      * for a Dict output; `none` otherwise.
      *
-     * Its presence (or {@link mergeSets}) selects the SEGMENT-MERGE assembly:
-     * partials are walked by their segment fences in the orchestrator, disjoint
-     * segments are byte-copied exactly as a splice does, and only overlapping
-     * ones are decoded, merged and re-encoded. Appended LAST (BEAST2 encodes
+     * 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 segment merge (union). The Set twin of
-     *  {@link merge}, which needs no function. Appended LAST. */
+    /** 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>;
@@ -164,34 +184,180 @@ export type PartitionTaskMetadata = ValueTypeOf<typeof PartitionTaskMetadataType
 export declare const encodePartitionTaskMetadata: (value: PartitionTaskMetadata) => Uint8Array;
 /**
  * Decode a `TaskObject.metadata` blob of a {@link TASK_KIND_PARTITION} task,
- * tolerating the pre-`merge` wire format (dual-decode migration).
+ * 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 `merge`/`mergeSets` defaulted off for
- *   older bytes
+ * @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, stream?, ...inputs]`;
- * 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.
+ * 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 wire input index 1 is the streamed input (producer tasks have
-     *  no streamed input). */
+    /** 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. */
-export declare const decodeStreamTaskMetadata: (data: Uint8Array) => StreamTaskMetadata;
+/**
+ * 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":"AAAA;;;GAGG;AAEH;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,SAAS,EAAE,QAAQ,EAAE,WAAW,EAAE,WAAW,EAAE,UAAU,EAAE,WAAW,EAA0C,MAAM,eAAe,CAAC;AAIvK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,eAAO,MAAM,cAAc;IACzB,kFAAkF;;IAElF,uEAAuE;;;;IAEvE,sEAAsE;;;;IAEtE,sFAAsF;;IAEtF,6FAA6F;;IAE7F;;;;;;;OAOG;;;;;;;;;;;;;;;IAEH;;;;;OAKG;;EAEH,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAC;AAEnD,MAAM,MAAM,UAAU,GAAG,WAAW,CAAC,OAAO,cAAc,CAAC,CAAC;AAmB5D;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU,CAW7D;AAMD;;;;kEAIkE;AAClE,eAAO,MAAM,mBAAmB,cAAc,CAAC;AAE/C;;;qDAGqD;AACrD,eAAO,MAAM,gBAAgB,WAAW,CAAC;AAEzC;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,yBAAyB;IACpC,2EAA2E;;IAE3E;mFAC+E;;IAE/E;sDACkD;;IAElD,qEAAqE;;IAErE;;;;;;;;;;OAUG;;IAEH;iEAC6D;;EAE7D,CAAC;AACH,MAAM,MAAM,yBAAyB,GAAG,OAAO,yBAAyB,CAAC;AAEzE,MAAM,MAAM,qBAAqB,GAAG,WAAW,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAclF,kFAAkF;AAClF,eAAO,MAAM,2BAA2B,EAAE,CAAC,KAAK,EAAE,qBAAqB,KAAK,UAChC,CAAC;AAK7C;;;;;;;GAOG;AACH,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,UAAU,GAAG,qBAAqB,CAUnF;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB;IACjC;8BAC0B;;IAE1B;;qBAEiB;;EAEjB,CAAC;AACH,MAAM,MAAM,sBAAsB,GAAG,OAAO,sBAAsB,CAAC;AAEnE,MAAM,MAAM,kBAAkB,GAAG,WAAW,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAE5E,+EAA+E;AAC/E,eAAO,MAAM,wBAAwB,EAAE,CAAC,KAAK,EAAE,kBAAkB,KAAK,UAC7B,CAAC;AAE1C,8EAA8E;AAC9E,eAAO,MAAM,wBAAwB,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,kBACpB,CAAC"}
+{"version":3,"file":"task.d.ts","sourceRoot":"","sources":["../../src/task.ts"],"names":[],"mappings":"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"}