@feasibleone/blong-gogo 1.36.0 → 1.37.0

package/src/chain.ts

@@ -1,5 +1,6 @@
-import {TestExecutor, type ITestLogger} from '@feasibleone/blong-chain';
+import {TestExecutor, type IStepProgress, type ITestLogger} from '@feasibleone/blong-chain';
 import {withProgress} from '@feasibleone/blong-lib';
+import type {IPlatformApi} from '@feasibleone/blong/types';
 import assert from 'node:assert';
 
 type Step = (a: typeof assert, results: object) => object | Promise<object>;
@@ -12,10 +13,227 @@ interface ITestContext {
     test: (name: string, fn: (t: unknown) => void | Promise<void>) => unknown;
 }
 
+/** Allure reporting options, as the framework config supplies them. */
+export interface IAllureRunOptions {
+    /** Write results at all. Off by default, on for a captured (CI) run. */
+    enabled?: boolean;
+    /** Results directory (default `allure-results`). */
+    outputDir?: string;
+    /** Trend history file (default `.allure/history.jsonl`). */
+    historyPath?: string;
+    /** Generate the HTML report when the session ends. */
+    generateOnEnd?: boolean;
+    /** Pattern with `{traceId}`, used to link a result to its log trace. */
+    logUrl?: string;
+}
+
+export interface IChainOptions {
+    /** The group's wire name, e.g. `test.order.checkpoint` — what Allure labels come from. */
+    method?: string;
+    allure?: IAllureRunOptions;
+    /**
+     * The platform this run belongs to, as `IPlatformApi` names it.
+     *
+     * Allure 3's format is a directory of files, so producing one needs a
+     * filesystem — and the browser platform has none. The platform is therefore what
+     * decides whether the attempt is made at all (see `canWriteReport`). A caller
+     * that names no platform is read as the server, which is what a direct chain run
+     * in Node is: refusing to report there would be worse than trying.
+     */
+    platform?: IPlatformApi['platform'];
+}
+
+/**
+ * `@feasibleone/blong-allure`, assembled rather than written out.
+ *
+ * A specifier written as a literal is *resolved* by the bundler even when the import
+ * is dynamic, so the whole integration was landing in every browser build: its modules
+ * import `node:fs`, `node:fs/promises`, `node:crypto`, `node:url` and
+ * `node:child_process`, none of which a browser can provide, and
+ * `browserBundle.test.ts` failed on exactly that list. Building the string at runtime
+ * leaves the specifier opaque to the bundler, which is the same trick `load.ts` uses
+ * (`extension` there) to keep the server half of the platform map out of a browser
+ * build — and it costs nothing on the server, where Node resolves the specifier when
+ * it is imported.
+ *
+ * The import is never *made* on a browser either: `canWriteReport` refuses the
+ * platform before it, because a browser has nowhere to write a report.
+ */
+const allurePackage = (): string => ['@feasibleone', 'blong-allure'].join('/');
+
+/**
+ * The one Allure session of this process, started by the first group that runs.
+ *
+ * A session clears its results directory, so it cannot be per group: the first
+ * group would wipe the results of the ones before it. It is started lazily
+ * instead, and ended by {@link endAllureSession} once every group has finished.
+ */
+let session: Promise<void> | undefined;
+
+/** The options the running session was started with, for its end. */
+let sessionOptions: IAllureRunOptions | undefined;
+
+/**
+ * Why this process will produce no Allure report, once that is known.
+ *
+ * Held for the run rather than per group, because the answer is the run's: a
+ * second group that says the same thing again adds noise to a run that has already
+ * explained why the report it asked for will not exist. `session` is never set
+ * while this is, so a blocked run also does not try to close a session later.
+ */
+let blocked: string | undefined;
+
+/**
+ * Whether this platform can write Allure's files at all.
+ *
+ * The browser platform is the one that cannot: it has no `node:fs`, so the lazy
+ * import of `blong-allure` there can only fail — and a failure caught per group is
+ * a failure reported per group over a run whose tests were fine. Its tests report
+ * through their own producer (Allure's Playwright integration), so the results this
+ * guard withholds are ones that were never going to exist on that platform.
+ *
+ * The allowed kinds are listed rather than the refused one, so a platform added
+ * later has to be considered here instead of inheriting a report nobody can write.
+ */
+function canWriteReport(platform: IChainOptions['platform']): boolean {
+    return platform === undefined || platform === 'server';
+}
+
+/** The results directory and history file, defaulted the way Allure documents them. */
+function sessionConfig(options: IAllureRunOptions): {
+    outputDir: string;
+    historyPath: string;
+    logUrl?: string;
+} {
+    return {
+        outputDir: options.outputDir ?? 'allure-results',
+        historyPath: options.historyPath ?? '.allure/history.jsonl',
+        logUrl: options.logUrl,
+    };
+}
+
+/**
+ * Start the Allure session if this run wants one, once.
+ *
+ * `blong-allure` is imported here rather than at the top of the file, for the
+ * reason the log implementation is chosen lazily: a run that does not report to
+ * Allure should not load it.
+ *
+ * The platform is checked *before* the attempt, and the reason it cannot report is
+ * said out loud — as a configuration mistake rather than an error in a test, so the
+ * absence of a report is explained rather than discovered.
+ *
+ * An unexpected failure (a package that cannot be imported on a platform that
+ * should be able to write results) is reported on the same terms, and the session
+ * is dropped rather than left rejected: there is nothing for the end of the run to
+ * close, and a later group must not await a promise that has already failed.
+ *
+ * This never throws. A report that cannot be written is not a test that failed —
+ * the run is judged on its tests — and a caller that had to guard the call would be
+ * one place too many for that decision to live.
+ */
+async function ensureSession(
+    options: IAllureRunOptions | undefined,
+    platform: IChainOptions['platform'],
+    log?: ITestLogger,
+): Promise<boolean> {
+    if (options?.enabled !== true || blocked !== undefined) return false;
+    if (!canWriteReport(platform)) {
+        blocked =
+            `Allure reporting is enabled for this run but the ${platform} platform cannot write its ` +
+            'files, so a report will not be produced';
+        log?.warn?.(blocked);
+        return false;
+    }
+    if (session === undefined) {
+        sessionOptions = options;
+        session = (async () => {
+            const {allureSessionStart} = await import(/* @vite-ignore */ allurePackage());
+            await allureSessionStart(sessionConfig(options));
+        })();
+    }
+    try {
+        await session;
+        return true;
+    } catch (error) {
+        // The first group to lose the session reports it; a group that was awaiting
+        // the same start loses it too and stays quiet, because the reason is the
+        // run's rather than its own.
+        session = undefined;
+        sessionOptions = undefined;
+        if (blocked === undefined) {
+            blocked = `Allure reporting failed: ${String(error)}`;
+            log?.error?.(error);
+        }
+        return false;
+    }
+}
+
+/**
+ * The Allure context for a group's wire name.
+ *
+ * `test.order.checkpoint` reads as realm `test`, collection `order`, group
+ * `checkpoint`. A name that does not split stays the realm, so a suite with its
+ * own naming still gets a label rather than a result filed under nothing.
+ */
+function contextOf(method: string | undefined, options: IAllureRunOptions) {
+    const [realm, collection, ...rest] = (method ?? '').split('.').filter(Boolean);
+    return {
+        realm,
+        collection,
+        group: rest.length > 0 ? rest.join('.') : undefined,
+        logUrl: options.logUrl,
+    };
+}
+
+/** The steps an executor recorded, in the order they completed. */
+function stepsOf(executor: TestExecutor): IStepProgress[] {
+    return Array.from(executor.getProgress().steps.values());
+}
+
+/** Write one group result, standing in for a step list its executor may not have. */
+async function writeGroupResult(
+    options: IAllureRunOptions,
+    name: string,
+    executor: TestExecutor,
+    method?: string,
+): Promise<void> {
+    const steps = stepsOf(executor);
+    if (steps.length === 0) return;
+    const {allureGroupResultWrite} = await import(/* @vite-ignore */ allurePackage());
+    await allureGroupResultWrite(
+        sessionConfig(options).outputDir,
+        {name, steps},
+        contextOf(method, options),
+    );
+}
+
+/**
+ * End the Allure session, if one was started, and optionally generate its report.
+ *
+ * Called by the runner once every group has finished, because the results
+ * directory belongs to the run rather than to any one group.
+ */
+export async function endAllureSession(): Promise<void> {
+    if (session === undefined) return;
+    const options = sessionOptions ?? {};
+    const closing = session;
+    session = undefined;
+    sessionOptions = undefined;
+    // Waiting on the start first: the end must not run the CLI over a results
+    // directory while the thing that lays it out is still opening it. A start that
+    // failed has already cleared `session` (see `ensureSession`), so this awaits one
+    // that opened, or that is opening.
+    await closing;
+    const {allureSessionEnd} = await import(/* @vite-ignore */ allurePackage());
+    await allureSessionEnd({...sessionConfig(options), generateOnEnd: options.generateOnEnd});
+}
+
 const runSteps =
     (
         steps: Steps,
         log?: ITestLogger,
+        options: IChainOptions = {},
         results = {$meta: {}},
     ): ((t: ITestContext) => Promise<void>) =>
     async (t: ITestContext) => {
@@ -33,6 +251,11 @@ const runSteps =
             resolvedSteps.push(await stepPromise);
         }
 
+        // Reporting is a run-level concern, and this call never throws: a report that
+        // cannot be written says so once and the run carries on being judged on its
+        // tests (see `ensureSession`).
+        const reporting = await ensureSession(options.allure, options.platform, log);
+
         // Execute with parallel executor, passing test context for nested output
         try {
             await withProgress(
@@ -57,6 +280,15 @@ const runSteps =
         } catch (error) {
             // Preserve error with context
             throw error;
+        } finally {
+            // The group is the test case: one result per group, written whether the
+            // group passed or not — a scenario that failed is the one a reader opens
+            // the report for. The group's own name is what it was run as.
+            if (reporting && options.allure) {
+                await writeGroupResult(options.allure, steps.name, executor, options.method).catch(
+                    error => log?.error?.(error),
+                );
+            }
         }
     };
 
@@ -92,8 +324,12 @@ const runSteps =
 export default async (
     test: ITestContext,
     log?: ITestLogger,
+    options: IChainOptions = {},
 ): Promise<(steps: Steps) => unknown> => {
     const context = test || (await import('node:test')).default;
     return steps =>
-        context.test(steps.name, runSteps(steps, log) as (t: unknown) => void | Promise<void>);
+        context.test(
+            steps.name,
+            runSteps(steps, log, options) as (t: unknown) => void | Promise<void>,
+        );
 };

package/src/checkpoint.test.ts

@@ -8,7 +8,12 @@
  * no emitter is attached, because a dispatch path must never reach the emitter's ambient
  * scope (F-197).
  */
-import type {IMeta} from '@feasibleone/blong/types';
+import type {
+    IMeta,
+    IProgressEntry,
+    IProgressPoint,
+    IProgressRegion,
+} from '@feasibleone/blong/types';
 import {
     attachSemanticVocabulary,
     detachSemanticVocabulary,
@@ -19,6 +24,14 @@ import {createAttachCheckpoint} from './checkpoint.ts';
 
 const MODES = ['production', 'debug', 'test'] as const;
 
+/** The points an invocation recorded, in the order it announced them. */
+const pointsOf = (progress: IProgressEntry[] | undefined): IProgressPoint[] =>
+    (progress ?? []).filter((entry): entry is IProgressPoint => entry.kind === 'point');
+
+/** The branches an invocation took, in the order it took them. */
+const regionsOf = (progress: IProgressEntry[] | undefined): IProgressRegion[] =>
+    (progress ?? []).filter((entry): entry is IProgressRegion => entry.kind === 'region');
+
 t.test('a branch is taken and its rationale kept, in every mode', t => {
     for (const mode of MODES) {
         const meta: IMeta = {};
@@ -29,9 +42,10 @@ t.test('a branch is taken and its rationale kept, in every mode', t => {
         ]);
         t.equal(result, 'declined', `${mode}: the branch is taken`);
         t.same(
-            meta.decisions,
+            meta.progress,
             [
                 {
+                    kind: 'region',
                     discriminator: 'rate-within-limit',
                     candidates: ['decline', 'accept'],
                     chosen: 'decline',
@@ -56,10 +70,85 @@ t.test('a checkpoint exists only where points are recorded', t => {
     const debug: IMeta = {};
     createAttachCheckpoint('debug')(debug);
     debug.checkpoint?.('total-calculated', {total: 200});
-    t.equal(debug.checkpoints?.length, 1, 'recorded where points are');
-    t.equal(debug.checkpoints?.[0]?.name, 'total-calculated');
-    t.same(debug.checkpoints?.[0]?.data, {total: 200});
-    t.type(debug.checkpoints?.[0]?.timestamp, 'number', 'and stamped when it happened');
+    const [point] = pointsOf(debug.progress);
+    t.equal(debug.progress?.length, 1, 'recorded where points are');
+    t.equal(point?.name, 'total-calculated');
+    t.same(point?.data, {total: 200});
+    t.type(point?.timestamp, 'number', 'and stamped when it happened');
+    t.end();
+});
+
+t.test('a point announced inside a branch names the branch it sat in', t => {
+    attachSemanticVocabulary(semantic);
+    t.teardown(() => detachSemanticVocabulary());
+    const meta: IMeta = {};
+    createAttachCheckpoint('test')(meta);
+    meta.checkpoint?.('before-the-branch');
+    meta.decide?.('rate-within-limit', {rate: 2}, [
+        {
+            name: 'decline',
+            when: () => true,
+            run: () => {
+                meta.checkpoint?.('declined');
+                return 'declined';
+            },
+        },
+        {name: 'accept', when: () => true, run: () => 'accepted'},
+    ]);
+
+    t.same(
+        meta.progress?.map(entry => entry.kind),
+        ['point', 'region', 'point'],
+        'the branch is announced where it was taken, between the points on either side of it',
+    );
+    t.same(
+        pointsOf(meta.progress).map(point => point.regions?.length ?? 0),
+        [0, 1],
+        'and only the point announced inside the branch names it, which is what nests a report',
+    );
+    t.same(
+        pointsOf(meta.progress)[1]?.regions,
+        [
+            {
+                discriminator: 'rate-within-limit',
+                candidates: ['decline', 'accept'],
+                chosen: 'decline',
+            },
+        ],
+        'by the names of the branch, not by a position the log mints for itself',
+    );
+    t.same(
+        regionsOf(meta.progress)[0]?.regions,
+        undefined,
+        'while the branch itself names nothing above it',
+    );
+    t.end();
+});
+
+t.test('a branch taken inside a branch names the one it sits in', t => {
+    attachSemanticVocabulary(semantic);
+    t.teardown(() => detachSemanticVocabulary());
+    const meta: IMeta = {};
+    createAttachCheckpoint('test')(meta);
+    meta.decide?.('outer', {}, [
+        {
+            name: 'taken',
+            when: () => true,
+            run: () =>
+                meta.decide?.('inner', {}, [{name: 'only', when: () => true, run: () => 'inner'}]),
+        },
+    ]);
+
+    t.same(
+        regionsOf(meta.progress).map(region => region.discriminator),
+        ['outer', 'inner'],
+        'both are announced, outermost first',
+    );
+    t.same(
+        regionsOf(meta.progress)[1]?.regions?.map(region => region.discriminator),
+        ['outer'],
+        'and the nested one is in the chain of the one that encloses it',
+    );
     t.end();
 });
 
@@ -119,7 +208,7 @@ t.test('no branch matching is a recorded non-choice', t => {
     const meta: IMeta = {};
     createAttachCheckpoint('test')(meta);
     t.equal(meta.decide?.('never', {}, [{name: 'a', when: () => false, run: () => 1}]), undefined);
-    t.equal(meta.decisions?.[0]?.chosen, 'none', 'and it is recorded as `none` rather than lost');
+    t.equal(regionsOf(meta.progress)[0]?.chosen, 'none', 'recorded as `none` rather than lost');
     t.end();
 });
 
@@ -159,7 +248,7 @@ t.test('a branch that throws records nothing', t => {
         'the failure is not swallowed',
     );
     t.notOk(
-        meta.decisions,
+        meta.progress,
         'a decision that never completed is not a decision, so nothing is recorded',
     );
     t.end();

package/src/checkpoint.ts

@@ -1,19 +1,50 @@
-import type {CheckpointFn, DecideFn, IMeta} from '@feasibleone/blong/types';
+import type {
+    CheckpointFn,
+    DecideFn,
+    IMeta,
+    IProgressPoint,
+    IProgressRegion,
+    IRegionMark,
+} from '@feasibleone/blong/types';
 import {vocabulary} from '@feasibleone/semantic-log/attachable';
 
 /**
- * Records a checkpoint in the $meta.checkpoints array, and announces it as a progress
- * point (PRD R26).
+ * The branches the calling scope is running inside, named the way `$meta` names them.
+ *
+ * Names only, and never the log's own mark: the mark carries the position it was minted at,
+ * which describes a place in *this* process' execution. An entry that travelled here from
+ * another process over a call would bring a position that means nothing here, while the three
+ * names still say exactly which branches it sat in — which is all a report groups by.
+ */
+const regionMarks = (): IRegionMark[] | undefined => {
+    const chain = vocabulary.currentRegions();
+    if (chain === undefined || chain.length === 0) {
+        return undefined;
+    }
+    return chain.map(region => ({
+        discriminator: region.discriminator,
+        candidates: region.candidates,
+        chosen: region.chosen,
+    }));
+};
+
+/**
+ * Reports a checkpoint into `$meta.progress`, and announces it as a progress point
+ * (PRD R26).
  *
  * Uses `this` binding — works correctly when called as
  * $meta.checkpoint?.('name', data) with optional chaining.
  */
 const checkpoint: CheckpointFn = function (this: IMeta, name: string, data?: unknown): void {
-    (this.checkpoints ??= []).push({
+    const regions = regionMarks();
+    const entry: IProgressPoint = {
+        kind: 'point',
         name,
-        data,
+        ...(data === undefined ? {} : {data}),
         timestamp: Date.now(),
-    });
+        ...(regions === undefined ? {} : {regions}),
+    };
+    (this.progress ??= []).push(entry);
     // The same moment is announced to the log, so a checkpoint reaches the record the
     // sequence diagram is drawn from rather than only the list a test asserts on. The
     // vocabulary degrades to nothing where no emitter is attached, so this is one call
@@ -22,13 +53,14 @@ const checkpoint: CheckpointFn = function (this: IMeta, name: string, data?: unk
 };
 
 /**
- * Takes a branch, and keeps the rationale on the invocation that took it (PRD R11/R26).
+ * Takes a branch, and keeps what it was and which one was taken on the invocation that took
+ * it (PRD R11/R26).
  *
  * `this`-bound like {@link checkpoint}. The branch's `run` is *wrapped* rather than the
  * predicates re-evaluated: a predicate with a side effect must run exactly once, and the
  * decision recorded has to be the one the code actually took. A branch whose `run` throws
- * records nothing — the throw propagates before the push, because a decision that never
- * completed is not a decision.
+ * records nothing — the entry is withdrawn before the throw propagates, because a decision
+ * that never completed is not a decision.
  */
 const decide: DecideFn = function <T>(
     this: IMeta,
@@ -48,14 +80,37 @@ const decide: DecideFn = function <T>(
             return branch.run();
         },
     }));
-    const result = vocabulary.decide<T>(discriminator, values, wrapped);
-    (this.decisions ??= []).push({
+    // The entry is pushed *before* the branch runs, which is what puts it where the
+    // announcement order wants it: the points the branch announces come after it in the
+    // array, and a report that groups by those points therefore draws them inside the
+    // branch. Nothing else in the entry is known yet, so `chosen` is filled in below.
+    const outer = regionMarks();
+    const entry: IProgressRegion = {
+        kind: 'region',
         discriminator,
         candidates: branches.map(branch => branch.name),
-        chosen: chosen ?? 'none',
+        chosen: '',
         values,
-    });
-    return result;
+        ...(outer === undefined ? {} : {regions: outer}),
+    };
+    const held = this.progress;
+    const progress = (this.progress ??= []);
+    progress.push(entry);
+    try {
+        const result = vocabulary.decide<T>(discriminator, values, wrapped);
+        entry.chosen = chosen ?? 'none';
+        return result;
+    } catch (error) {
+        // A branch whose `run` throws records nothing, which is the rule this recorder has
+        // always kept: a decision that never completed is not a decision. The entry was
+        // pushed early, so it is withdrawn again — and, where the array was this call's own,
+        // the slot goes with it, so a throwing branch leaves `$meta.progress` exactly as
+        // absent as it found it. The throw still propagates.
+        const at = progress.lastIndexOf(entry);
+        if (at !== -1) progress.splice(at, 1);
+        if (held === undefined && progress.length === 0) delete this.progress;
+        throw error;
+    }
 };
 
 /**

package/src/ci.intent.test.ts

@@ -0,0 +1,94 @@
+import {server} from '@feasibleone/blong';
+import {test} from 'tap';
+
+import load from './loadServer.ts';
+
+/**
+ * The `ci` block is a captured run's configuration — colours off, Allure results
+ * written — and a CI run is one by definition, so `activeConfigs` activates the
+ * block for it whether or not the entry named the intent.
+ *
+ * What made this worth a test: only the entries that remembered to pass `ci` in CI
+ * wrote Allure results, so a package whose only runner is tap produced no report and
+ * the CI summary had nothing to link for it. The observable here is the same trick
+ * `exit.intent.test.ts` uses — a config key that only the `ci` block sets — because
+ * the resolved `watch.allure.enabled` is not exposed on the registry.
+ *
+ * Only `load` is exercised, never `start`: the assertions are about which config
+ * blocks merged. Every load is stopped, since the `integration` intent opens the
+ * semantic-log cluster service and a registry that is never stopped leaves the suite
+ * reporting `timeout!` instead of passing (`exit.intent.test.ts` explains it at
+ * length).
+ */
+
+/**
+ * The suite the load is built from. `pkg` is supplied so the loader skips its
+ * `createRequire(mod.url)('./package.json')` lookup, and `parentConfig` is an object
+ * rather than a name so the test does not depend on the working directory.
+ */
+const suite = (config: object) =>
+    server(
+        () =>
+            ({
+                url: import.meta.url,
+                pkg: {name: 'ci-intent-test', version: '0.0.0'},
+                children: [],
+                config: {default: {}, ...config},
+            }) as never,
+    );
+
+/** The `exit` the run resolves, with `ci` as the only thing that sets it. */
+async function exitWithCiBlock(intents: string[]): Promise<boolean | undefined> {
+    const registry = await load(
+        suite({ci: {exit: true}}) as unknown as Parameters<typeof load>[0],
+        'ci-intent-test',
+        {},
+        intents,
+    );
+    try {
+        return registry.exit;
+    } finally {
+        await registry.stop();
+    }
+}
+
+/** Run `fn` with `CI` set the way a runner sets it, and restore it afterwards. */
+async function withCi<T>(value: string | undefined, fn: () => Promise<T>): Promise<T> {
+    const previous = process.env['CI'];
+    if (value === undefined) delete process.env['CI'];
+    else process.env['CI'] = value;
+    try {
+        return await fn();
+    } finally {
+        if (previous === undefined) delete process.env['CI'];
+        else process.env['CI'] = previous;
+    }
+}
+
+test('a CI run activates the ci block without being asked', async t => {
+    t.equal(
+        await withCi('true', () => exitWithCiBlock([])),
+        true,
+        'the block merged although no intent named it',
+    );
+    t.equal(
+        await withCi('true', () => exitWithCiBlock(['dev', 'integration'])),
+        true,
+        'the intents a run normally passes do not take it away',
+    );
+});
+
+test('a run that is not CI needs the intent', async t => {
+    // `false`, not `undefined`: the registry always carries a boolean once loaded.
+    // Deleting `CI` rather than inheriting it, because this suite runs in CI itself.
+    t.equal(
+        await withCi(undefined, () => exitWithCiBlock([])),
+        false,
+        'the block stays out of a run whose output is watched',
+    );
+    t.equal(
+        await withCi(undefined, () => exitWithCiBlock(['ci'])),
+        true,
+        'and naming it still does what it always did',
+    );
+});

package/src/codec/adapter/jsonrpc/receive.ts

@@ -1,4 +1,4 @@
-import {handler, type IMeta, type ITypedError} from '@feasibleone/blong/types';
+import {handler, type IMeta, type IProgressEntry, type ITypedError} from '@feasibleone/blong/types';
 import {type Response} from 'got';
 
 export default handler(({errors}) => ({
@@ -8,7 +8,7 @@ export default handler(({errors}) => ({
             error?: unknown;
             validation?: unknown;
             debug?: unknown;
-            checkpoints?: unknown[];
+            progress?: unknown[];
         }>,
         $meta?: IMeta,
     ) {
@@ -54,8 +54,8 @@ export default handler(({errors}) => ({
                 }),
             });
         } else if (typeof body === 'object' && 'result' in body && !('error' in body)) {
-            if ($meta && body.checkpoints?.length) {
-                ($meta.checkpoints ??= []).push(...body.checkpoints);
+            if ($meta && body.progress?.length) {
+                ($meta.progress ??= []).push(...(body.progress as IProgressEntry[]));
             }
             return body.result;
         } else {