@lde/pipeline 0.43.0 → 0.45.0

package/dist/distribution/importResolver.js

@@ -105,25 +105,25 @@ export class ImportResolver {
                 await this.options.server.start();
             }
             catch (error) {
-                callbacks?.onImportFailed?.(importResult.distribution, error instanceof Error ? error.message : String(error));
+                callbacks?.onImportFailed?.(importResult.distribution, error instanceof Error ? error : new Error(String(error)));
                 return new NoDistributionAvailable(dataset, 'SPARQL server failed to start after import', probeResults);
             }
             const distribution = Distribution.sparql(this.options.server.queryEndpoint, importResult.identifier);
             distribution.subjectFilter = importResult.distribution.subjectFilter;
             return new ResolvedDistribution(distribution, probeResults, {
                 from: importResult.distribution,
-                duration: Date.now() - importStart,
+                durationMs: Date.now() - importStart,
                 tripleCount: importResult.tripleCount,
                 engine: importResult.engine,
             });
         }
         if (importResult.type === 'failed') {
-            callbacks?.onImportFailed?.(importResult.distribution, importResult.error);
+            callbacks?.onImportFailed?.(importResult.distribution, new Error(importResult.error));
             return new NoDistributionAvailable(dataset, 'No SPARQL endpoint or importable data dump available', probeResults, importResult);
         }
         if (importResult.type === 'not-supported') {
             const failedDistribution = importResult.distribution ?? candidates[0];
-            callbacks?.onImportFailed?.(failedDistribution, 'No supported import format');
+            callbacks?.onImportFailed?.(failedDistribution, new Error('No supported import format'));
             return new NoDistributionAvailable(dataset, 'No supported import format available', probeResults);
         }
         // Unreachable by type, but not at runtime: an importer built against an

package/dist/distribution/resolver.d.ts

@@ -15,7 +15,7 @@ export interface ImportDetails {
     /** The data dump that was imported. */
     readonly from: Distribution;
     /** Milliseconds the import took. */
-    readonly duration: number;
+    readonly durationMs: number;
     /** Triples in the imported data, when the importer can tell. */
     readonly tripleCount?: number;
     /** The engine that built the imported data, when the importer can tell. */
@@ -56,7 +56,7 @@ export interface ResolveCallbacks {
     /** Called when a data-dump import begins (resolve phase). */
     onImportStart?: () => void;
     /** Called when importing a distribution fails (resolve phase). */
-    onImportFailed?: (distribution: Distribution, error: string) => void;
+    onImportFailed?: (distribution: Distribution, error: Error) => void;
 }
 /**
  * Resolves a dataset to a usable distribution in two phases so the pipeline can

package/dist/distribution/resolver.d.ts.map

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

package/dist/index.d.ts

@@ -3,7 +3,8 @@ export * from './namespaceAlias.js';
 export * from './asyncQueue.js';
 export * from './batch.js';
 export * from './pipeline.js';
-export * from './progressReporter.js';
+export * from './pipelineEvent.js';
+export * from './reporter.js';
 export * from './selector.js';
 export * from './stage.js';
 export * from './stageOutputResolver.js';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,qBAAqB,CAAC;AACpC,cAAc,iBAAiB,CAAC;AAChC,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC;AAC9B,cAAc,uBAAuB,CAAC;AACtC,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC;AAC3B,cAAc,0BAA0B,CAAC;AACzC,cAAc,uBAAuB,CAAC;AACtC,cAAc,mBAAmB,CAAC;AAClC,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,mBAAmB,CAAC;AAClC,cAAc,wBAAwB,CAAC;AACvC,cAAc,oCAAoC,CAAC;AACnD,cAAc,oCAAoC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,qBAAqB,CAAC;AACpC,cAAc,iBAAiB,CAAC;AAChC,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC;AAC9B,cAAc,oBAAoB,CAAC;AACnC,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC;AAC3B,cAAc,0BAA0B,CAAC;AACzC,cAAc,uBAAuB,CAAC;AACtC,cAAc,mBAAmB,CAAC;AAClC,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,mBAAmB,CAAC;AAClC,cAAc,wBAAwB,CAAC;AACvC,cAAc,oCAAoC,CAAC;AACnD,cAAc,oCAAoC,CAAC"}

package/dist/index.js

@@ -3,7 +3,8 @@ export * from './namespaceAlias.js';
 export * from './asyncQueue.js';
 export * from './batch.js';
 export * from './pipeline.js';
-export * from './progressReporter.js';
+export * from './pipelineEvent.js';
+export * from './reporter.js';
 export * from './selector.js';
 export * from './stage.js';
 export * from './stageOutputResolver.js';

package/dist/pipeline.d.ts

@@ -7,7 +7,7 @@ import type { Writer } from './writer/writer.js';
 import { type DistributionResolver } from './distribution/resolver.js';
 import type { ProvenanceStore } from './provenance/store.js';
 import type { StageOutputResolver } from './stageOutputResolver.js';
-import type { ProgressReporter } from './progressReporter.js';
+import type { Reporter } from './reporter.js';
 import { type TimeoutPolicy } from './sparql/timeoutPolicy.js';
 /**
  * Why a run was abandoned rather than committed: its selector produced no
@@ -90,13 +90,8 @@ export interface PipelineOptions<Out = Quad> {
         stageOutputResolver: StageOutputResolver;
         outputDir: string;
     };
-    /**
-     * Observer(s) notified of pipeline lifecycle events. Pass an array to have
-     * several reporters observe the same run – e.g. a console reporter alongside
-     * a verdict-collecting one; every reporter receives each event in array
-     * order. A single reporter may be passed directly.
-     */
-    reporter?: ProgressReporter | readonly ProgressReporter[];
+    /** Reporter(s) handed every {@link PipelineEvent} of a run, in array order. */
+    reporter?: Reporter | readonly Reporter[];
     /**
      * Optional per-dataset processing memory. When set, the pipeline skips a
      * dataset whose source-change fingerprint and {@link pipelineVersion} both
@@ -134,13 +129,15 @@ export declare class Pipeline<Out = Quad> {
     private readonly beforeDatasetWrite?;
     private readonly distributionResolver;
     private readonly chaining?;
-    private readonly reporter?;
+    private readonly reporters;
     private readonly timeoutFactory;
     private readonly provenanceStore?;
     private readonly pipelineVersion?;
     constructor(options: PipelineOptions<Out>);
     run(): Promise<void>;
     private processDataset;
+    private report;
+    private reportStageFailed;
     /** Persist the processing record for a dataset, when a store is configured. */
     private recordOutcome;
     private reportValidators;

package/dist/pipeline.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pipeline.d.ts","sourceRoot":"","sources":["../src/pipeline.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"pipeline.d.ts","sourceRoot":"","sources":["../src/pipeline.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAgB,MAAM,cAAc,CAAC;AACrD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAEzC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AACrD,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD,OAAO,KAAK,EAKV,MAAM,EACP,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EACL,KAAK,oBAAoB,EAI1B,MAAM,4BAA4B,CAAC;AAKpC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAW7D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AASpE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAG9C,OAAO,EAEL,KAAK,aAAa,EACnB,MAAM,2BAA2B,CAAC;AAEnC;;;;;;;;;;;GAWG;AACH,qBAAa,cAAe,SAAQ,KAAK;;CAOxC;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,uBAAuB;IACtC,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;;GAKG;AACH,MAAM,WAAW,yBAAyB;IACxC,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,wDAAwD;AACxD,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb;;;;;;OAMG;IACH,gBAAgB,CAAC,EAAE,aAAa,CAAC,uBAAuB,CAAC,CAAC;IAC1D;;;;;;;;;;;;OAYG;IACH,kBAAkB,CAAC,EAAE,aAAa,CAAC,yBAAyB,CAAC,CAAC;CAC/D;AAED,MAAM,WAAW,eAAe,CAAC,GAAG,GAAG,IAAI;IACzC,eAAe,EAAE,eAAe,CAAC;IACjC,MAAM,EAAE,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC;IACrC;;;;;;;OAOG;IACH,OAAO,CAAC,EAAE,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,CAAC,GAAG,cAAc,EAAE,GAAG,KAAK,CAAC;IAC1D,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,oBAAoB,CAAC,EAAE,oBAAoB,CAAC;IAC5C,QAAQ,CAAC,EAAE;QACT,mBAAmB,EAAE,mBAAmB,CAAC;QACzC,SAAS,EAAE,MAAM,CAAC;KACnB,CAAC;IACF,+EAA+E;IAC/E,QAAQ,CAAC,EAAE,QAAQ,GAAG,SAAS,QAAQ,EAAE,CAAC;IAC1C;;;;;;OAMG;IACH,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC;;;;;;OAMG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;;;;;;;;OASG;IACH,OAAO,CAAC,EAAE,MAAM,aAAa,CAAC;CAC/B;AA0OD,qBAAa,QAAQ,CAAC,GAAG,GAAG,IAAI;IAC9B,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAS;IAC9B,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAkB;IAClD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAe;IACtC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAc;IACrC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAC,CAAyC;IAC3E,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAC,CAA2C;IAC/E,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAuB;IAC5D,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAmC;IAC7D,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAsB;IAChD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAsB;IACrD,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAkB;IACnD,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAS;gBAE9B,OAAO,EAAE,eAAe,CAAC,GAAG,CAAC;IAyDnC,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;YAyFZ,cAAc;IA8R5B,OAAO,CAAC,MAAM;IAyBd,OAAO,CAAC,iBAAiB;IAczB,+EAA+E;YACjE,aAAa;YAuBb,gBAAgB;IAgB9B,OAAO,CAAE,aAAa;IAStB;;;;;OAKG;IACH,OAAO,CAAC,WAAW;IAgBnB;;;;;;;;OAQG;IACH,OAAO,CAAC,0BAA0B;IA+BlC;;;;;;OAMG;YACW,SAAS;IAuCvB;;;OAGG;YACW,QAAQ;IAoEtB,2EAA2E;YAC7D,eAAe;YAuBf,QAAQ;YA+EP,SAAS;CAczB"}

package/dist/pipeline.js

@@ -9,8 +9,8 @@ import { sourceFingerprint } from './provenance/sourceFingerprint.js';
 import { shouldReprocess } from './provenance/reprocessDecision.js';
 import { NetworkError, SparqlProbeResult, } from '@lde/distribution-probe';
 import { importOutcomeToVerdict, probeResultToVerdict, } from '@lde/distribution-health';
-import { NotSupported } from './sparql/reader.js';
-import { combineReporters } from './combineReporters.js';
+import { NoItemsSelected, NotSupported } from './sparql/reader.js';
+import { levelOf, } from './pipelineEvent.js';
 import { UnreadValueTally } from './unreadValueTally.js';
 import { ConstantTimeoutPolicy, } from './sparql/timeoutPolicy.js';
 /**
@@ -238,7 +238,7 @@ export class Pipeline {
     beforeDatasetWrite;
     distributionResolver;
     chaining;
-    reporter;
+    reporters;
     timeoutFactory;
     provenanceStore;
     pipelineVersion;
@@ -278,11 +278,7 @@ export class Pipeline {
         this.distributionResolver =
             options.distributionResolver ?? new SparqlDistributionResolver();
         this.chaining = options.chaining;
-        // `Array.isArray` narrows the array branch but not the readonly-array out of
-        // the else branch, so cast the single-reporter case explicitly.
-        this.reporter = Array.isArray(options.reporter)
-            ? combineReporters(options.reporter)
-            : options.reporter;
+        this.reporters = [options.reporter ?? []].flat();
         this.timeoutFactory =
             options.timeout ?? (() => new ConstantTimeoutPolicy(300_000));
         this.provenanceStore = options.provenanceStore;
@@ -290,7 +286,8 @@ export class Pipeline {
     }
     async run() {
         const start = Date.now();
-        this.reporter?.pipelineStart?.(this.name);
+        const runId = randomUUID();
+        this.report(runId, { type: 'pipelineStart', name: this.name });
         // Fail fast on a store that cannot persist records (e.g. a provenance
         // file on a mount the runtime user cannot write to): every dataset would
         // process fine, but the records would be lost and skip-unchanged would
@@ -298,17 +295,21 @@ export class Pipeline {
         await this.provenanceStore?.check?.();
         const selectStart = Date.now();
         const datasets = await this.datasetSelector.select();
-        this.reporter?.datasetsSelected?.(datasets.total, Date.now() - selectStart);
+        this.report(runId, {
+            type: 'datasetsSelected',
+            count: datasets.total,
+            durationMs: Date.now() - selectStart,
+        });
         // The run transaction: one openRun → write* → commit/abort per pipeline
         // run. `selectedSources` accumulates every selected dataset – including
         // ones skipped as unchanged – so a writer's commit can sweep by registry
         // membership.
         const selectedSources = [];
         const context = {
-            runId: randomUUID(),
+            runId,
             startedAt: new Date().toISOString(),
             selectedSources: () => selectedSources,
-            itemsRejected: (dataset, rejection) => this.reporter?.itemsRejected?.(dataset, rejection),
+            itemsRejected: (dataset, rejection) => this.report(runId, { type: 'itemsRejected', dataset, rejection }),
             provenance: this.provenanceStore,
         };
         const openedWriter = await this.writer.openRun(context);
@@ -350,36 +351,61 @@ export class Pipeline {
         // meant not to do.
         if (abandoned) {
             const reason = new EmptySelection();
-            this.reporter?.selectionEmpty?.(reason.message);
+            this.report(runId, { type: 'selectionEmpty', message: reason.message });
             await runWriter.abort(reason);
         }
         const finalMemory = process.memoryUsage();
-        this.reporter?.pipelineComplete?.({
-            duration: Date.now() - start,
+        this.report(runId, {
+            type: 'pipelineComplete',
+            durationMs: Date.now() - start,
             memoryUsageBytes: finalMemory.rss,
             heapUsedBytes: finalMemory.heapUsed,
         });
     }
     async processDataset(dataset, runWriter, context) {
-        this.reporter?.datasetStart?.(dataset);
+        const { runId } = context;
+        const datasetStart = Date.now();
+        this.report(runId, { type: 'datasetStart', dataset });
+        const skip = (reason) => this.report(runId, { type: 'datasetSkipped', dataset, reason });
+        const skipOnError = (code, prefix, thrown) => {
+            const error = thrown instanceof Error
+                ? thrown
+                : new Error(String(thrown), { cause: thrown });
+            this.report(runId, {
+                type: 'datasetSkipped',
+                dataset,
+                reason: { code, message: `${prefix}: ${error.message}` },
+                error,
+            });
+        };
         // Probe phase: gather probe results and the source-to-be, without importing.
         let probed;
         try {
             probed = await this.distributionResolver.probe(dataset, {
                 onProbe: (distribution, result) => {
-                    this.reporter?.distributionProbed?.(mapProbeResult(distribution, result));
+                    this.report(runId, {
+                        type: 'distributionProbed',
+                        dataset,
+                        distribution,
+                        result: mapProbeResult(distribution, result),
+                    });
                     // Shallow validity: the probe parse-validates small RDF bodies as a
                     // by-product. Surface that verdict per distribution, judged against
                     // the distribution's own observed fingerprint.
                     const verdict = probeResultToVerdict(result, sourceFingerprint(distribution, result));
                     if (verdict) {
-                        this.reporter?.distributionValidated?.(distribution, verdict);
+                        this.report(runId, {
+                            type: 'distributionValidated',
+                            dataset,
+                            distribution,
+                            verdict,
+                        });
                     }
                 },
             });
         }
         catch (error) {
-            this.reporter?.datasetSkipped?.(dataset, `Distribution probing failed: ${error instanceof Error ? error.message : String(error)}`);
+            skipOnError('probeFailed', 'Distribution probing failed', error);
             return;
         }
         // Derive the source-change fingerprint from the probed source: null for a
@@ -406,24 +432,26 @@ export class Pipeline {
                 sourceFingerprint: fingerprint,
                 pipelineVersion: this.pipelineVersion,
             }, stored)) {
-                this.reporter?.datasetSkipped?.(dataset, 'Unchanged since last run');
+                skip({ code: 'unchanged', message: 'Unchanged since last run' });
                 return;
             }
         }
         // Resolve phase: import a data dump only when the source is one.
+        const importCallbacks = {
+            onImportStart: () => this.report(runId, { type: 'importStarted', dataset }),
+            onImportFailed: (distribution, error) => this.report(runId, {
+                type: 'importFailed',
+                dataset,
+                distribution,
+                error,
+            }),
+        };
         let resolved;
         try {
-            resolved = await this.distributionResolver.resolve(probed, {
-                onImportStart: () => {
-                    this.reporter?.importStarted?.();
-                },
-                onImportFailed: (distribution, error) => {
-                    this.reporter?.importFailed?.(distribution, error);
-                },
-            });
+            resolved = await this.distributionResolver.resolve(probed, importCallbacks);
         }
         catch (error) {
-            this.reporter?.datasetSkipped?.(dataset, `Distribution resolution failed: ${error instanceof Error ? error.message : String(error)}`);
+            skipOnError('resolveFailed', 'Distribution resolution failed', error);
             return;
         }
         if (resolved instanceof NoDistributionAvailable) {
@@ -432,20 +460,29 @@ export class Pipeline {
             // no summary, so an invalid distribution is recorded rather than silently
             // dropped.
             if (resolved.importFailed) {
-                this.reporter?.distributionValidated?.(resolved.importFailed.distribution, importOutcomeToVerdict(resolved.importFailed, fingerprint));
+                this.report(runId, {
+                    type: 'distributionValidated',
+                    dataset,
+                    distribution: resolved.importFailed.distribution,
+                    verdict: importOutcomeToVerdict(resolved.importFailed, fingerprint),
+                });
             }
             // Record the failure so a dataset whose source is unchanged is not
             // re-imported every run; it is retried at the next fingerprint change or
             // version rotation.
-            await this.recordOutcome(dataset, fingerprint, 'failed');
-            this.reporter?.datasetSkipped?.(dataset, resolved.message);
+            await this.recordOutcome(runId, dataset, fingerprint, 'failed');
+            skip({ code: 'noDistributionAvailable', message: resolved.message });
             return;
         }
-        this.reportSelectedDistribution(dataset, resolved, fingerprint);
+        this.reportSelectedDistribution(runId, dataset, resolved, fingerprint);
         const timeout = this.timeoutFactory();
         const unsubscribe = timeout.subscribe?.({
-            onTighten: (event) => this.reporter?.timeoutTightened?.(event),
-            onRelax: (event) => this.reporter?.timeoutRelaxed?.(event),
+            onTighten: (transition) => this.report(runId, {
+                ...transition,
+                type: 'timeoutTightened',
+                dataset,
+            }),
+            onRelax: (transition) => this.report(runId, { ...transition, type: 'timeoutRelaxed', dataset }),
         });
         let stageFailed = false;
         // What the kept attempt’s stages could not read, reported once the dataset
@@ -467,10 +504,7 @@ export class Pipeline {
                 // path. The dataset stays recorded as failed (stageFailed is already
                 // true) and processing continues with the next dataset.
                 try {
-                    const fallback = await this.distributionResolver.resolveFallback(probed, {
-                        onImportStart: () => this.reporter?.importStarted?.(),
-                        onImportFailed: (distribution, error) => this.reporter?.importFailed?.(distribution, error),
-                    });
+                    const fallback = await this.distributionResolver.resolveFallback(probed, importCallbacks);
                     if (fallback instanceof ResolvedDistribution) {
                         // The dump is now the dataset's effective source: report it as
                         // selected/validated under its own change fingerprint so the next
@@ -484,7 +518,7 @@ export class Pipeline {
                                 fallbackFingerprint = sourceFingerprint(dump, dumpProbeResult);
                             }
                         }
-                        this.reportSelectedDistribution(dataset, fallback, fallbackFingerprint);
+                        this.reportSelectedDistribution(runId, dataset, fallback, fallbackFingerprint);
                         // Discard the endpoint-sourced partial output before the re-run so
                         // the dump-sourced stats replace it rather than appending to it.
                         await runWriter.reset?.(dataset);
@@ -503,11 +537,16 @@ export class Pipeline {
                         // A failed dump import is a deep validity verdict on that dump –
                         // surface it rather than silently keeping the endpoint's partial
                         // output, matching the primary NoDistributionAvailable path.
-                        this.reporter?.distributionValidated?.(fallback.importFailed.distribution, importOutcomeToVerdict(fallback.importFailed, fingerprint));
+                        this.report(runId, {
+                            type: 'distributionValidated',
+                            dataset,
+                            distribution: fallback.importFailed.distribution,
+                            verdict: importOutcomeToVerdict(fallback.importFailed, fingerprint),
+                        });
                     }
                 }
                 catch (error) {
-                    this.reporter?.stageFailed?.('reactive-dump-fallback', error instanceof Error ? error : new Error(String(error)));
+                    this.reportStageFailed(runId, dataset, 'reactive-dump-fallback', error);
                 }
             }
         }
@@ -522,26 +561,60 @@ export class Pipeline {
             // A per-dataset writer failure must not abort the whole run: isolate it
             // like a stage failure so the remaining datasets still process. The
             // dataset is recorded 'failed' below and retried on the next run.
-            this.reporter?.stageFailed?.('write', error instanceof Error ? error : new Error(String(error)));
+            this.reportStageFailed(runId, dataset, 'write', error);
             stageFailed = true;
         }
-        await this.reportValidators(dataset);
+        await this.reportValidators(runId, dataset);
         // A dataset whose stages threw produced incomplete output; record it as
         // ‘failed’ rather than freezing a broken result under a ‘success’ record.
-        await this.recordOutcome(dataset, fingerprint, stageFailed ? 'failed' : 'success');
+        await this.recordOutcome(runId, dataset, fingerprint, stageFailed ? 'failed' : 'success');
         if (!stageFailed && unread !== undefined) {
             for (const entry of unread.entries()) {
-                this.reporter?.valuesUnread?.(dataset, entry);
+                this.report(runId, { type: 'valuesUnread', dataset, unread: entry });
             }
         }
         const datasetMemory = process.memoryUsage();
-        this.reporter?.datasetComplete?.(dataset, {
+        this.report(runId, {
+            type: 'datasetComplete',
+            dataset,
+            durationMs: Date.now() - datasetStart,
             memoryUsageBytes: datasetMemory.rss,
             heapUsedBytes: datasetMemory.heapUsed,
         });
     }
+    report(runId, payload) {
+        if (this.reporters.length === 0)
+            return;
+        const event = {
+            ...payload,
+            defaultLevel: levelOf(payload),
+            timestamp: new Date(),
+            runId,
+        };
+        for (const reporter of this.reporters) {
+            // A reporter only observes the run, so its failure must not change it:
+            // the other reporters still get the event, and the run carries on.
+            try {
+                reporter.onEvent(event);
+            }
+            catch (error) {
+                process.emitWarning(`A reporter threw on a ${event.type} event: ${error instanceof Error ? error.message : String(error)}`, {
+                    type: 'ReporterWarning',
+                    detail: error instanceof Error ? error.stack : undefined,
+                });
+            }
+        }
+    }
+    reportStageFailed(runId, dataset, stage, error) {
+        this.report(runId, {
+            type: 'stageFailed',
+            dataset,
+            stage,
+            error: error instanceof Error ? error : new Error(String(error)),
+        });
+    }
     /** Persist the processing record for a dataset, when a store is configured. */
-    async recordOutcome(dataset, fingerprint, status) {
+    async recordOutcome(runId, dataset, fingerprint, status) {
         if (!this.provenanceStore)
             return;
         try {
@@ -557,10 +630,10 @@ export class Pipeline {
             // reprocesses next run, its record not yet updated – but it must be
             // surfaced: a store that fails every write silently disables
             // skip-unchanged.
-            this.reporter?.stageFailed?.('provenance', error instanceof Error ? error : new Error(String(error)));
+            this.reportStageFailed(runId, dataset, 'provenance', error);
         }
     }
-    async reportValidators(dataset) {
+    async reportValidators(runId, dataset) {
         const validators = new Set();
         for (const stage of this.collectStages(this.stages)) {
             if (stage.validator)
@@ -568,7 +641,7 @@ export class Pipeline {
         }
         for (const validator of validators) {
             const report = await validator.report(dataset);
-            this.reporter?.datasetValidated?.(dataset, report);
+            this.report(runId, { type: 'datasetValidated', dataset, report });
         }
     }
     // Walks every stage and sub-stage to collect validators; it reads only
@@ -603,15 +676,25 @@ export class Pipeline {
      * yielded no triples); native SPARQL endpoints are not imported and carry no
      * deep verdict.
      */
-    reportSelectedDistribution(dataset, resolved, fingerprint) {
-        this.reporter?.distributionSelected?.(dataset, resolved.distribution, resolved.imported);
+    reportSelectedDistribution(runId, dataset, resolved, fingerprint) {
+        this.report(runId, {
+            type: 'distributionSelected',
+            dataset,
+            distribution: resolved.distribution,
+            imported: resolved.imported,
+        });
         if (resolved.imported) {
-            this.reporter?.distributionValidated?.(resolved.imported.from, importOutcomeToVerdict({
-                type: 'successful',
+            this.report(runId, {
+                type: 'distributionValidated',
+                dataset,
                 distribution: resolved.imported.from,
-                tripleCount: resolved.imported.tripleCount,
-                warnings: [],
-            }, fingerprint));
+                verdict: importOutcomeToVerdict({
+                    type: 'successful',
+                    distribution: resolved.imported.from,
+                    tripleCount: resolved.imported.tripleCount,
+                    warnings: [],
+                }, fingerprint),
+            });
         }
     }
     /**
@@ -630,12 +713,12 @@ export class Pipeline {
                     await this.runChain(dataset, distribution, stage, runWriter, context, timeout);
                 }
                 else {
-                    await this.runStage(dataset, distribution, stage, this.stageWriter(runWriter, stage.name), timeout, unread);
+                    await this.runStage(context.runId, dataset, distribution, stage, this.stageWriter(runWriter, stage.name), timeout, unread);
                 }
             }
             catch (error) {
                 stageFailed = true;
-                this.reporter?.stageFailed?.(stage.name, error instanceof Error ? error : new Error(String(error)));
+                this.reportStageFailed(context.runId, dataset, stage.name, error);
             }
         }
         return { stageFailed, unread };
@@ -644,17 +727,21 @@ export class Pipeline {
      * Run a stage with reporting and return whether it was supported.
      * Returns `true` if the stage produced results, `false` if NotSupported.
      */
-    async runStage(dataset, distribution, stage, writer, timeout, unread) {
-        this.reporter?.stageStart?.(stage.name);
+    async runStage(runId, dataset, distribution, stage, writer, timeout, unread) {
+        this.report(runId, { type: 'stageStart', dataset, stage: stage.name });
         const stageStart = Date.now();
         let itemsProcessed = 0;
         let quadsGenerated = 0;
+        let summary;
         const result = await stage.run(dataset, distribution, writer, {
             onProgress: (items, quads) => {
                 itemsProcessed = items;
                 quadsGenerated = quads;
                 const stageMemory = process.memoryUsage();
-                this.reporter?.stageProgress?.({
+                this.report(runId, {
+                    type: 'stageProgress',
+                    dataset,
+                    stage: stage.name,
                     itemsProcessed,
                     quadsGenerated,
                     memoryUsageBytes: stageMemory.rss,
@@ -663,21 +750,38 @@ export class Pipeline {
             },
             timeout,
             valueUnread: unread && ((target, field, value) => unread.add(target, field, value)),
+            onComplete: (stageSummary) => {
+                summary = stageSummary;
+            },
         });
         if (result instanceof NotSupported) {
-            this.reporter?.stageSkipped?.(stage.name, result.message);
+            this.report(runId, {
+                type: 'stageSkipped',
+                dataset,
+                stage: stage.name,
+                reason: {
+                    code: result instanceof NoItemsSelected
+                        ? 'noItemsSelected'
+                        : 'notSupported',
+                    message: result.message,
+                },
+            });
             return false;
         }
-        this.reporter?.stageComplete?.(stage.name, {
+        this.report(runId, {
+            type: 'stageComplete',
+            dataset,
+            stage: stage.name,
             itemsProcessed,
             quadsGenerated,
-            duration: Date.now() - stageStart,
+            durationMs: Date.now() - stageStart,
+            ...summary,
         });
         return true;
     }
     /** Run a stage in chained mode, throwing if the stage is not supported. */
-    async runChainedStage(dataset, distribution, stage, writer, timeout) {
-        const supported = await this.runStage(dataset, distribution, stage, writer, timeout);
+    async runChainedStage(runId, dataset, distribution, stage, writer, timeout) {
+        const supported = await this.runStage(runId, dataset, distribution, stage, writer, timeout);
         if (!supported) {
             throw new Error(`Stage '${stage.name}' returned NotSupported in chained mode`);
         }
@@ -698,7 +802,7 @@ export class Pipeline {
             });
             const scratchRun = await scratchWriter.openRun(context);
             try {
-                await this.runChainedStage(dataset, stageDistribution, chainedStage, scratchRun, timeout);
+                await this.runChainedStage(context.runId, dataset, stageDistribution, chainedStage, scratchRun, timeout);
                 await scratchRun.flush(dataset, 'success');
                 await scratchRun.commit();
             }
@@ -751,7 +855,6 @@ function mapProbeResult(distribution, result) {
     const fingerprint = sourceFingerprint(distribution, result);
     if (result instanceof NetworkError) {
         return {
-            distribution,
             type: 'network-error',
             available: false,
             error: result.message,
@@ -760,7 +863,6 @@ function mapProbeResult(distribution, result) {
         };
     }
     return {
-        distribution,
         type: result instanceof SparqlProbeResult
             ? 'sparql'
             : 'data-dump',