@lde/pipeline 0.43.0 → 0.45.0

package/dist/stage.js

@@ -1,6 +1,7 @@
-import { NotSupported } from './sparql/reader.js';
+import { NoItemsSelected, NotSupported } from './sparql/reader.js';
 import { batch } from './batch.js';
 import { AsyncQueue } from './asyncQueue.js';
+import { StageTally } from './stageTally.js';
 export class Stage {
     name;
     stages;
@@ -56,15 +57,21 @@ export class Stage {
         const distribution = this.sourceFor
             ? this.sourceFor(dataset, resolved)
             : resolved;
+        const tally = new StageTally(this.transformNames);
         if (this.itemSelector) {
-            return this.runWithSelector(this.itemSelector.select(distribution, this.batchSize, {
+            const result = await this.runWithSelector(tally.selected(this.itemSelector.select(distribution, this.batchSize, {
                 timeout,
-            }), dataset, distribution, writer, options);
+            })), dataset, distribution, writer, tally, options);
+            if (!(result instanceof NotSupported)) {
+                options?.onComplete?.(tally.summary());
+            }
+            return result;
         }
-        const streams = await this.readAll(dataset, distribution, timeout);
-        if (streams instanceof NotSupported) {
-            return streams;
+        const chains = await this.readAll(dataset, distribution, timeout, tally);
+        if (chains instanceof NotSupported) {
+            return chains;
         }
+        const streams = chains.map(({ stream }) => stream);
         // The non-selector path has no batch, so `project` is forbidden here (the
         // constructor rejects `project` without an `itemSelector`). It therefore
         // only ever writes quads, and `Out` is `Quad` at runtime – tsc cannot see
@@ -73,6 +80,7 @@ export class Stage {
         // Quads the readers produced (before any validation filtering); used to
         // enforce `expectsOutput` below.
         let produced = 0;
+        const write = (quads) => tally.written(quads, (timedQuads) => quadWriter.write(dataset, timedQuads));
         if (this.validation) {
             const buffer = [];
             for (const stream of streams) {
@@ -84,16 +92,16 @@ export class Stage {
             const onInvalid = this.validation.onInvalid ?? 'write';
             if (onInvalid === 'write') {
                 await Promise.all([
-                    quadWriter.write(dataset, (async function* () {
+                    write((async function* () {
                         yield* buffer;
                     })()),
-                    this.validation.validator.validate(buffer, dataset),
+                    tally.validated(this.validation.validator.validate(buffer, dataset)),
                 ]);
             }
             else {
-                const accepted = await this.validateBuffer(buffer, dataset);
+                const accepted = await tally.validated(this.validateBuffer(buffer, dataset));
                 if (accepted.length > 0) {
-                    await quadWriter.write(dataset, (async function* () {
+                    await write((async function* () {
                         yield* accepted;
                     })());
                 }
@@ -101,15 +109,19 @@ export class Stage {
         }
         else if (this.expectsOutput) {
             // Only thread the per-quad counter through when the count is actually
-            // needed; the default path stays a plain streaming write with no overhead.
-            await quadWriter.write(dataset, countQuads(mergeStreams(streams), (count) => {
+            // needed.
+            await write(countQuads(mergeStreams(streams), (count) => {
                 produced = count;
             }));
         }
         else {
-            await quadWriter.write(dataset, mergeStreams(streams));
+            await write(mergeStreams(streams));
+        }
+        for (const { settle } of chains) {
+            settle();
         }
         this.assertProduced(produced);
+        options?.onComplete?.(tally.summary());
     }
     /**
      * Throw when {@link StageOptions.expectsOutput} is set but the stage produced
@@ -121,14 +133,14 @@ export class Stage {
             throw new Error(`Stage '${this.name}' expected output but produced none`);
         }
     }
-    async runWithSelector(selector, dataset, distribution, writer, options) {
+    async runWithSelector(selector, dataset, distribution, writer, tally, options) {
         // Peek the first batch to detect an empty selector before starting the
         // writer (important because e.g. SparqlUpdateWriter does CLEAR GRAPH).
         const batches = batch(selector, this.batchSize);
         const iter = batches[Symbol.asyncIterator]();
         const first = await iter.next();
         if (first.done) {
-            return new NotSupported('No items selected');
+            return new NoItemsSelected();
         }
         // Reconstruct a full iterable including the peeked first batch.
         const allBatches = (async function* () {
@@ -178,19 +190,16 @@ export class Stage {
                     }
                     track((async () => {
                         // Run all readers for this batch in parallel.
-                        const readerOutputs = await Promise.all(this.readers.map(async ({ reader, transforms }) => {
-                            const result = await reader.read(dataset, distribution, {
-                                bindings,
-                                timeout: options?.timeout,
-                            });
+                        const readerOutputs = await Promise.all(this.readers.map(async (normalized) => {
+                            const result = await this.read(normalized, dataset, distribution, { bindings, timeout: options?.timeout }, tally);
                             if (result instanceof NotSupported)
                                 return [];
                             hasResults = true;
-                            const stream = this.applyTransforms(transforms, result, dataset, distribution);
                             const quads = [];
-                            for await (const quad of stream) {
+                            for await (const quad of result.stream) {
                                 quads.push(quad);
                             }
+                            result.settle();
                             return quads;
                         }));
                         const batchQuads = readerOutputs.flat();
@@ -201,19 +210,21 @@ export class Stage {
                         if (this.validation &&
                             batchQuads.length > 0 &&
                             onInvalid !== 'write') {
-                            acceptedQuads = await this.validateBuffer(batchQuads, dataset);
+                            acceptedQuads = await tally.validated(this.validateBuffer(batchQuads, dataset));
                         }
                         // The one type-changing seam: project the root-complete batch into
                         // output items, or pass the quads through for a plain stage (`Out`
                         // is `Quad` at runtime when there is no projection).
-                        const items = this.project
-                            ? this.project(acceptedQuads, {
+                        const project = this.project;
+                        const items = project
+                            ? tally.projected(() => project(acceptedQuads, {
                                 dataset,
                                 distribution,
                                 stage: this.name,
                                 bindings,
+                                count: countIn(tally),
                                 valueUnread: options?.valueUnread ?? ignoreUnreadValue,
-                            })
+                            }))
                             : acceptedQuads;
                         for await (const item of items) {
                             await queue.push(item);
@@ -222,7 +233,7 @@ export class Stage {
                         if (this.validation &&
                             batchQuads.length > 0 &&
                             onInvalid === 'write') {
-                            pendingValidations.push(this.validation.validator.validate(batchQuads, dataset));
+                            pendingValidations.push(tally.validated(this.validation.validator.validate(batchQuads, dataset)));
                         }
                         itemsProcessed += bindings.length;
                         options?.onProgress?.(itemsProcessed, quadsGenerated);
@@ -246,7 +257,7 @@ export class Stage {
         const dispatchPromise = dispatch();
         const writePromise = (async () => {
             try {
-                await writer.write(dataset, queue);
+                await tally.written(queue, (items) => writer.write(dataset, items));
             }
             catch (err) {
                 queue.abort(err);
@@ -275,49 +286,51 @@ export class Stage {
         // 'skip': discard
         return [];
     }
-    async readAll(dataset, distribution, timeout) {
-        const results = await Promise.all(this.readers.map(async ({ reader, transforms }) => {
-            const result = await reader.read(dataset, distribution, {
-                timeout,
-            });
-            if (result instanceof NotSupported)
-                return result;
-            return this.applyTransforms(transforms, result, dataset, distribution);
-        }));
-        const streams = [];
+    async readAll(dataset, distribution, timeout, tally) {
+        const results = await Promise.all(this.readers.map((normalized) => this.read(normalized, dataset, distribution, { timeout }, tally)));
+        const chains = [];
         for (const result of results) {
             if (!(result instanceof NotSupported)) {
-                streams.push(result);
+                chains.push(result);
             }
         }
-        if (streams.length === 0) {
+        if (chains.length === 0) {
             return new NotSupported('All readers returned NotSupported');
         }
-        return streams;
+        return chains;
     }
     /**
-     * Fold a reader's attached transforms over its output stream, in order,
-     * supplying the {@link ReaderContext}. A transform sees one `read()`
-     * call's output (see {@link AttachedReader}); `NotSupported` is handled by
-     * the caller and never reaches a transform.
+     * Run one reader and fold its attached transforms over its output, in order,
+     * supplying the {@link ReaderContext}, each layer timed by `tally`. A
+     * transform sees one `read()` call's output (see {@link AttachedReader});
+     * `NotSupported` is returned as is and never reaches a transform.
      */
-    applyTransforms(transforms, stream, dataset, distribution) {
-        if (transforms.length === 0)
-            return stream;
+    async read({ reader, transforms, firstTransform }, dataset, distribution, readOptions, tally) {
+        const started = performance.now();
+        const result = await reader.read(dataset, distribution, readOptions);
+        tally.addRead(performance.now() - started);
+        if (result instanceof NotSupported)
+            return result;
         const context = {
             dataset,
             distribution,
             stage: this.name,
+            count: countIn(tally),
         };
-        return transforms.reduce((quads, transform) => transform(quads, context), stream);
+        return tally.chain(result, transforms.map((transform) => (quads) => transform(quads, context)), firstTransform);
+    }
+    /** Every attached transform’s name, readers in order, for the phase tally. */
+    get transformNames() {
+        return this.readers.flatMap(({ transforms, firstTransform }) => transforms.map((transform, index) => transform.name || `transform ${firstTransform + index + 1}`));
     }
 }
 /** Normalise the {@link StageReaders} union to reader + transforms pairs. */
 function normalizeReaders(readers) {
     const list = Array.isArray(readers) ? readers : [readers];
+    let firstTransform = 0;
     return list.map((entry) => {
         if ('read' in entry) {
-            return { reader: entry, transforms: [] };
+            return { reader: entry, transforms: [], firstTransform };
         }
         const { reader, transform } = entry;
         const transforms = transform === undefined
@@ -325,7 +338,9 @@ function normalizeReaders(readers) {
             : Array.isArray(transform)
                 ? [...transform]
                 : [transform];
-        return { reader, transforms };
+        const normalized = { reader, transforms, firstTransform };
+        firstTransform += transforms.length;
+        return normalized;
     });
 }
 async function* mergeStreams(streams) {
@@ -350,6 +365,10 @@ async function* countQuads(stream, onCount) {
     }
     onCount(count);
 }
+/** The {@link ReaderContext.count} that adds to `tally`. */
+function countIn(tally) {
+    return (name, amount = 1) => tally.count(name, amount);
+}
 /** The {@link BatchContext.valueUnread} a stage run without a receiver hands
  *  its transform. */
 function ignoreUnreadValue() {

package/dist/stageTally.d.ts

@@ -0,0 +1,56 @@
+import type { StageSummary } from './pipelineEvent.js';
+/**
+ * Adds up, over every batch one {@link Stage.run} runs, where it spends its
+ * time, phase by phase, and what its transforms and projection count.
+ *
+ * A stage streams: a reader’s quads flow through its transforms into the
+ * writer, and every layer pulls from the one before it. Timing a layer from its
+ * first quad to its last would count the layers upstream of it too. So the tally
+ * times only the wait on each layer’s `next()`, and takes a layer’s own time as
+ * its wait minus the wait of the layer it pulls from. That holds as long as a
+ * layer pulls from upstream only while its own `next()` is pending, which an
+ * async generator does; a transform that prefetches in the background has its
+ * time undercounted, never below zero.
+ */
+export declare class StageTally {
+    private selectMs;
+    private readMs;
+    private validateMs;
+    private projectMs;
+    private writeMs;
+    private readonly transforms;
+    private readonly counts;
+    /** `transformNames` lists every attached transform, readers in order. */
+    constructor(transformNames: readonly string[]);
+    /** The item selector, timed while it is iterated. */
+    selected<T>(selector: AsyncIterable<T>): AsyncIterable<T>;
+    /** How long a reader took to answer, before its quads stream. */
+    addRead(milliseconds: number): void;
+    /**
+     * Time one reader’s output and the transforms folded over it. `apply` builds
+     * the next layer from the one before; `firstTransform` is the position of the
+     * reader’s first transform among all of the stage’s.
+     *
+     * Returns the timed stream and a `settle` to call once that stream is drained,
+     * which adds this chain’s times to the tally.
+     */
+    chain<T>(source: AsyncIterable<T>, layers: readonly ((upstream: AsyncIterable<T>) => AsyncIterable<T>)[], firstTransform: number): {
+        stream: AsyncIterable<T>;
+        settle: () => void;
+    };
+    /** Time validating one buffer of quads. */
+    validated<T>(validation: Promise<T>): Promise<T>;
+    /** Time projecting one batch: building the items, then iterating them. */
+    projected<T>(project: () => Iterable<T> | AsyncIterable<T>): AsyncIterable<T>;
+    /**
+     * Time the writer: `write` is handed the items to write and runs to
+     * completion. The time it spent waiting on those items is not its own.
+     */
+    written<T>(items: AsyncIterable<T>, write: (items: AsyncIterable<T>) => Promise<void>): Promise<void>;
+    /** Add `amount` to the count called `name`. */
+    count(name: string, amount: number): void;
+    /** What the stage counted, and its phases rounded to whole milliseconds. */
+    summary(): StageSummary;
+    private phases;
+}
+//# sourceMappingURL=stageTally.d.ts.map

package/dist/stageTally.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stageTally.d.ts","sourceRoot":"","sources":["../src/stageTally.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,YAAY,EAEb,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;GAYG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,QAAQ,CAAK;IACrB,OAAO,CAAC,MAAM,CAAK;IACnB,OAAO,CAAC,UAAU,CAAK;IACvB,OAAO,CAAC,SAAS,CAAK;IACtB,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAsB;IACjD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA8B;IAErD,yEAAyE;gBAC7D,cAAc,EAAE,SAAS,MAAM,EAAE;IAI7C,qDAAqD;IACrD,QAAQ,CAAC,CAAC,EAAE,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC;IAMzD,iEAAiE;IACjE,OAAO,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI;IAInC;;;;;;;OAOG;IACH,KAAK,CAAC,CAAC,EACL,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,EACxB,MAAM,EAAE,SAAS,CAAC,CAAC,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,aAAa,CAAC,CAAC,CAAC,CAAC,EAAE,EACrE,cAAc,EAAE,MAAM,GACrB;QAAE,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC;QAAC,MAAM,EAAE,MAAM,IAAI,CAAA;KAAE;IA6BnD,2CAA2C;IACrC,SAAS,CAAC,CAAC,EAAE,UAAU,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAStD,0EAA0E;IAC1E,SAAS,CAAC,CAAC,EACT,OAAO,EAAE,MAAM,QAAQ,CAAC,CAAC,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,GAC5C,aAAa,CAAC,CAAC,CAAC;IASnB;;;OAGG;IACG,OAAO,CAAC,CAAC,EACb,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,KAAK,EAAE,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,GAChD,OAAO,CAAC,IAAI,CAAC;IAchB,+CAA+C;IAC/C,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAIzC,4EAA4E;IAC5E,OAAO,IAAI,YAAY;IAIvB,OAAO,CAAC,MAAM;CAaf"}

package/dist/stageTally.js

@@ -0,0 +1,164 @@
+/**
+ * Adds up, over every batch one {@link Stage.run} runs, where it spends its
+ * time, phase by phase, and what its transforms and projection count.
+ *
+ * A stage streams: a reader’s quads flow through its transforms into the
+ * writer, and every layer pulls from the one before it. Timing a layer from its
+ * first quad to its last would count the layers upstream of it too. So the tally
+ * times only the wait on each layer’s `next()`, and takes a layer’s own time as
+ * its wait minus the wait of the layer it pulls from. That holds as long as a
+ * layer pulls from upstream only while its own `next()` is pending, which an
+ * async generator does; a transform that prefetches in the background has its
+ * time undercounted, never below zero.
+ */
+export class StageTally {
+    selectMs = 0;
+    readMs = 0;
+    validateMs = 0;
+    projectMs = 0;
+    writeMs = 0;
+    transforms;
+    counts = {};
+    /** `transformNames` lists every attached transform, readers in order. */
+    constructor(transformNames) {
+        this.transforms = transformNames.map((name) => ({ name, durationMs: 0 }));
+    }
+    /** The item selector, timed while it is iterated. */
+    selected(selector) {
+        return timed(selector, (milliseconds) => {
+            this.selectMs += milliseconds;
+        });
+    }
+    /** How long a reader took to answer, before its quads stream. */
+    addRead(milliseconds) {
+        this.readMs += milliseconds;
+    }
+    /**
+     * Time one reader’s output and the transforms folded over it. `apply` builds
+     * the next layer from the one before; `firstTransform` is the position of the
+     * reader’s first transform among all of the stage’s.
+     *
+     * Returns the timed stream and a `settle` to call once that stream is drained,
+     * which adds this chain’s times to the tally.
+     */
+    chain(source, layers, firstTransform) {
+        // waits[0] is the reader’s, waits[k] the k-th transform’s, each including
+        // the waits before it.
+        const waits = layers.map(() => 0).concat(0);
+        let stream = timed(source, (milliseconds) => {
+            waits[0] += milliseconds;
+        });
+        // A transform’s own work before it returns its stream is its time alone.
+        const built = layers.map(() => 0);
+        layers.forEach((layer, index) => {
+            const started = performance.now();
+            const upstream = layer(stream);
+            built[index] = performance.now() - started;
+            stream = timed(upstream, (milliseconds) => {
+                waits[index + 1] += milliseconds;
+            });
+        });
+        return {
+            stream,
+            settle: () => {
+                this.readMs += waits[0];
+                for (let index = 0; index < layers.length; index++) {
+                    this.transforms[firstTransform + index].durationMs +=
+                        built[index] + Math.max(0, waits[index + 1] - waits[index]);
+                }
+            },
+        };
+    }
+    /** Time validating one buffer of quads. */
+    async validated(validation) {
+        const started = performance.now();
+        try {
+            return await validation;
+        }
+        finally {
+            this.validateMs += performance.now() - started;
+        }
+    }
+    /** Time projecting one batch: building the items, then iterating them. */
+    projected(project) {
+        const started = performance.now();
+        const items = project();
+        this.projectMs += performance.now() - started;
+        return timed(items, (milliseconds) => {
+            this.projectMs += milliseconds;
+        });
+    }
+    /**
+     * Time the writer: `write` is handed the items to write and runs to
+     * completion. The time it spent waiting on those items is not its own.
+     */
+    async written(items, write) {
+        let waitedMs = 0;
+        const started = performance.now();
+        try {
+            await write(timed(items, (milliseconds) => {
+                waitedMs += milliseconds;
+            }));
+        }
+        finally {
+            this.writeMs += Math.max(0, performance.now() - started - waitedMs);
+        }
+    }
+    /** Add `amount` to the count called `name`. */
+    count(name, amount) {
+        this.counts[name] = (this.counts[name] ?? 0) + amount;
+    }
+    /** What the stage counted, and its phases rounded to whole milliseconds. */
+    summary() {
+        return { phases: this.phases(), counts: { ...this.counts } };
+    }
+    phases() {
+        return {
+            selectMs: Math.round(this.selectMs),
+            readMs: Math.round(this.readMs),
+            transforms: [...sumByName(this.transforms)].map(([name, durationMs]) => ({
+                name,
+                durationMs: Math.round(durationMs),
+            })),
+            validateMs: Math.round(this.validateMs),
+            projectMs: Math.round(this.projectMs),
+            writeMs: Math.round(this.writeMs),
+        };
+    }
+}
+/** Add up the durations of transforms sharing a name, in order first seen. */
+function sumByName(transforms) {
+    const sums = new Map();
+    for (const { name, durationMs } of transforms) {
+        sums.set(name, (sums.get(name) ?? 0) + durationMs);
+    }
+    return sums;
+}
+/**
+ * Pass `source` through unchanged, reporting each wait on its `next()` to
+ * `onWait`. Accepts a plain iterable too, for a projection that returns an
+ * array.
+ */
+function timed(source, onWait) {
+    return {
+        [Symbol.asyncIterator]() {
+            const iterator = Symbol.asyncIterator in source
+                ? source[Symbol.asyncIterator]()
+                : source[Symbol.iterator]();
+            return {
+                async next() {
+                    const started = performance.now();
+                    try {
+                        return await iterator.next();
+                    }
+                    finally {
+                        onWait(performance.now() - started);
+                    }
+                },
+                async return(value) {
+                    return (await iterator.return?.(value)) ?? { done: true, value };
+                },
+            };
+        },
+    };
+}

package/dist/unreadValueTally.d.ts

@@ -1,7 +1,7 @@
-import type { UnreadValue, ValuesUnread } from './progressReporter.js';
+import type { UnreadValue, ValuesUnread } from './pipelineEvent.js';
 /**
  * The values a dataset’s stages could not read, tallied per (target, field)
- * for {@link ProgressReporter.valuesUnread}. Bounded by the schema, not the
+ * for the `valuesUnread` event. Bounded by the schema, not the
  * data: one entry per field that rejected anything, each holding a count and
  * at most {@link MAX_EXAMPLES} distinct examples.
  *

package/dist/unreadValueTally.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"unreadValueTally.d.ts","sourceRoot":"","sources":["../src/unreadValueTally.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAKvE;;;;;;;GAOG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAGpB;IAEJ,0DAA0D;IAC1D,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,GAAG,IAAI;IAiB7D,mEAAmE;IACnE,OAAO,IAAI,SAAS,YAAY,EAAE;CAGnC"}
+{"version":3,"file":"unreadValueTally.d.ts","sourceRoot":"","sources":["../src/unreadValueTally.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAKpE;;;;;;;GAOG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAGpB;IAEJ,0DAA0D;IAC1D,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,GAAG,IAAI;IAiB7D,mEAAmE;IACnE,OAAO,IAAI,SAAS,YAAY,EAAE;CAGnC"}

package/dist/unreadValueTally.js

@@ -2,7 +2,7 @@
 const MAX_EXAMPLES = 5;
 /**
  * The values a dataset’s stages could not read, tallied per (target, field)
- * for {@link ProgressReporter.valuesUnread}. Bounded by the schema, not the
+ * for the `valuesUnread` event. Bounded by the schema, not the
  * data: one entry per field that rejected anything, each holding a count and
  * at most {@link MAX_EXAMPLES} distinct examples.
  *

package/dist/writer/writer.d.ts

@@ -1,7 +1,7 @@
 import { Dataset } from '@lde/dataset';
 import type { Quad } from '@rdfjs/types';
 import type { ProvenanceStore } from '../provenance/store.js';
-import type { ItemsRejected } from '../progressReporter.js';
+import type { ItemsRejected } from '../pipelineEvent.js';
 /**
  * Context for one pipeline run, handed to {@link Writer.openRun}.
  */

package/dist/writer/writer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"writer.d.ts","sourceRoot":"","sources":["../../src/writer/writer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAE5D;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB;;;;OAIG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB;;;OAGG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B;;;;;OAKG;IACH,eAAe,IAAI,QAAQ,CAAC,MAAM,CAAC,CAAC;IACpC;;;;;;;OAOG;IACH,aAAa,CAAC,CAAC,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,aAAa,GAAG,IAAI,CAAC;IACjE;;;OAGG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,eAAe,CAAC;CACvC;AAED;;;;GAIG;AACH,MAAM,WAAW,aAAa,CAAC,IAAI,GAAG,IAAI;IACxC;;;;;;OAMG;IACH,KAAK,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,aAAa,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACpE;AAED;;;;GAIG;AACH,MAAM,MAAM,cAAc,GAAG,SAAS,GAAG,QAAQ,CAAC;AAElD;;;;;;;GAOG;AACH,MAAM,WAAW,SAAS,CAAC,IAAI,GAAG,IAAI,CAAE,SAAQ,aAAa,CAAC,IAAI,CAAC;IACjE;;;;;;;;;;OAUG;IACH,KAAK,CAAC,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEjE;;;;;;;;;OASG;IACH,KAAK,CAAC,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAExC;;;;;;;;;OASG;IACH,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAExB;;;;;;OAMG;IACH,KAAK,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAErC;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,OAAO,CAAC,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACzC;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,MAAM,CAAC,IAAI,GAAG,IAAI;IACjC;;;;OAIG;IACH,OAAO,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC;CACxD"}
+{"version":3,"file":"writer.d.ts","sourceRoot":"","sources":["../../src/writer/writer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEzD;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB;;;;OAIG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB;;;OAGG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B;;;;;OAKG;IACH,eAAe,IAAI,QAAQ,CAAC,MAAM,CAAC,CAAC;IACpC;;;;;;;OAOG;IACH,aAAa,CAAC,CAAC,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,aAAa,GAAG,IAAI,CAAC;IACjE;;;OAGG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,eAAe,CAAC;CACvC;AAED;;;;GAIG;AACH,MAAM,WAAW,aAAa,CAAC,IAAI,GAAG,IAAI;IACxC;;;;;;OAMG;IACH,KAAK,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,aAAa,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACpE;AAED;;;;GAIG;AACH,MAAM,MAAM,cAAc,GAAG,SAAS,GAAG,QAAQ,CAAC;AAElD;;;;;;;GAOG;AACH,MAAM,WAAW,SAAS,CAAC,IAAI,GAAG,IAAI,CAAE,SAAQ,aAAa,CAAC,IAAI,CAAC;IACjE;;;;;;;;;;OAUG;IACH,KAAK,CAAC,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEjE;;;;;;;;;OASG;IACH,KAAK,CAAC,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAExC;;;;;;;;;OASG;IACH,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAExB;;;;;;OAMG;IACH,KAAK,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAErC;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,OAAO,CAAC,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACzC;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,MAAM,CAAC,IAAI,GAAG,IAAI;IACjC;;;;OAIG;IACH,OAAO,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC;CACxD"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lde/pipeline",
-  "version": "0.43.0",
+  "version": "0.45.0",
   "repository": {
     "url": "git+https://github.com/ldelements/lde.git",
     "directory": "packages/pipeline"

package/dist/combineReporters.d.ts

@@ -1,16 +0,0 @@
-import type { ProgressReporter } from './progressReporter.js';
-/**
- * Combine several {@link ProgressReporter}s into one that forwards every
- * lifecycle call to each child that implements it. Lets a single run be
- * observed by more than one reporter – e.g. a console reporter alongside a
- * verdict-collecting one.
- *
- * Each method is dispatched to the children in array order; a child that does
- * not implement a given (optional) method is skipped for that call.
- *
- * Internal to the package: not re-exported from `index.ts`. {@link Pipeline}
- * uses it to normalise a `reporter` array into the single reporter its call
- * sites expect, so the broader API need not grow a new public symbol.
- */
-export declare function combineReporters(reporters: readonly ProgressReporter[]): ProgressReporter;
-//# sourceMappingURL=combineReporters.d.ts.map

package/dist/combineReporters.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"combineReporters.d.ts","sourceRoot":"","sources":["../src/combineReporters.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAU9D;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE,SAAS,gBAAgB,EAAE,GACrC,gBAAgB,CAiDlB"}

package/dist/combineReporters.js

@@ -1,57 +0,0 @@
-/**
- * Combine several {@link ProgressReporter}s into one that forwards every
- * lifecycle call to each child that implements it. Lets a single run be
- * observed by more than one reporter – e.g. a console reporter alongside a
- * verdict-collecting one.
- *
- * Each method is dispatched to the children in array order; a child that does
- * not implement a given (optional) method is skipped for that call.
- *
- * Internal to the package: not re-exported from `index.ts`. {@link Pipeline}
- * uses it to normalise a `reporter` array into the single reporter its call
- * sites expect, so the broader API need not grow a new public symbol.
- */
-export function combineReporters(reporters) {
-    const forward = (method, ...args) => {
-        for (const reporter of reporters) {
-            // Cast to the concrete signature for `method`: indexing by a generic key
-            // yields a union of method types TS won't call directly, even though the
-            // arguments are correlated.
-            const handler = reporter[method];
-            // Every method is optional; notify only the children that implement it.
-            // Invoke through `call` so a class-based reporter keeps its `this`: a bare
-            // `handler?.(...)` would drop the receiver and break methods that touch
-            // instance state (e.g. ConsoleReporter’s spinner).
-            handler?.call(reporter, ...args);
-        }
-    };
-    // Listing every method explicitly (rather than a Proxy) keeps the forwarding
-    // type-safe: typing the result as `Required<ProgressReporter>` forces a new
-    // entry here whenever the interface grows, so a forgotten method fails to
-    // compile instead of silently going unforwarded.
-    const combined = {
-        pipelineStart: (...args) => forward('pipelineStart', ...args),
-        datasetsSelected: (...args) => forward('datasetsSelected', ...args),
-        selectionEmpty: (...args) => forward('selectionEmpty', ...args),
-        datasetStart: (...args) => forward('datasetStart', ...args),
-        distributionProbed: (...args) => forward('distributionProbed', ...args),
-        importStarted: (...args) => forward('importStarted', ...args),
-        importFailed: (...args) => forward('importFailed', ...args),
-        distributionValidated: (...args) => forward('distributionValidated', ...args),
-        distributionSelected: (...args) => forward('distributionSelected', ...args),
-        stageStart: (...args) => forward('stageStart', ...args),
-        stageProgress: (...args) => forward('stageProgress', ...args),
-        stageComplete: (...args) => forward('stageComplete', ...args),
-        stageFailed: (...args) => forward('stageFailed', ...args),
-        stageSkipped: (...args) => forward('stageSkipped', ...args),
-        datasetValidated: (...args) => forward('datasetValidated', ...args),
-        datasetComplete: (...args) => forward('datasetComplete', ...args),
-        datasetSkipped: (...args) => forward('datasetSkipped', ...args),
-        itemsRejected: (...args) => forward('itemsRejected', ...args),
-        valuesUnread: (...args) => forward('valuesUnread', ...args),
-        pipelineComplete: (...args) => forward('pipelineComplete', ...args),
-        timeoutTightened: (...args) => forward('timeoutTightened', ...args),
-        timeoutRelaxed: (...args) => forward('timeoutRelaxed', ...args),
-    };
-    return combined;
-}