@feasibleone/blong-gogo 1.36.0 → 1.37.0

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## [1.37.0](https://github.com/feasibleone/blong/compare/blong-gogo-v1.36.0...blong-gogo-v1.37.0) (2026-09-26)
+
+
+### Features
+
+* progress points in test reports ([fb73036](https://github.com/feasibleone/blong/commit/fb730360877eb371ab3d1603ae7bf35976c170dc))
+
+
+### Bug Fixes
+
+* chain dynamic import ([7db222f](https://github.com/feasibleone/blong/commit/7db222f0a6469b624fa1935027f63b0593585ee6))
+* misc CI failures ([950289d](https://github.com/feasibleone/blong/commit/950289d65e6187d10658dd0fd76361bd4d3d56e8))
+
 ## [1.36.0](https://github.com/feasibleone/blong/compare/blong-gogo-v1.35.0...blong-gogo-v1.36.0) (2026-09-24)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@feasibleone/blong-gogo",
-  "version": "1.36.0",
+  "version": "1.37.0",
   "repository": {
     "url": "git+https://github.com/feasibleone/blong.git"
   },
@@ -20,7 +20,6 @@
   },
   "dependencies": {
     "@apidevtools/swagger-parser": "^12.1.0",
-    "@modelcontextprotocol/sdk": "^1.0.0",
     "@aws-sdk/client-s3": "^3.1037.0",
     "@fastify/basic-auth": "^6.2.0",
     "@fastify/bearer-auth": "^10.1.2",
@@ -33,6 +32,7 @@
     "@fastify/swagger-ui": "^5.2.5",
     "@fastify/type-provider-typebox": "^6.1.0",
     "@feasibleone/blong": "^1.0.0",
+    "@feasibleone/blong-allure": "^1.0.0",
     "@feasibleone/blong-chain": "^1.0.0",
     "@feasibleone/blong-config": "^1.0.0",
     "@feasibleone/blong-lib": "^1.0.0",
@@ -41,6 +41,7 @@
     "@feasibleone/semantic-log": "^1.0.0",
     "@keycloak/keycloak-admin-client": "^26.6.2",
     "@kubernetes/client-node": "^1.4.0",
+    "@modelcontextprotocol/sdk": "^1.0.0",
     "@octokit/rest": "^22.0.1",
     "@sinclair/typebox-codegen": "^0.11.1",
     "@slack/webhook": "^7.0.7",
@@ -91,7 +92,7 @@
     "tap": "^21.6.3",
     "typescript": "^6.0.3",
     "vite": "^8.2.1",
-    "@feasibleone/blong-dev": "1.6.0"
+    "@feasibleone/blong-dev": "1.7.0"
   },
   "scripts": {
     "browser-check": "node scripts/browser-compat-check.mjs",

package/src/Gateway.ts

@@ -462,7 +462,7 @@ export default class Gateway extends Internal implements IGateway {
                                                           Type.Number(),
                                                       ]),
                                                       result: value.result,
-                                                      checkpoints: Type.Optional(
+                                                      progress: Type.Optional(
                                                           Type.Array(Type.Any()),
                                                       ),
                                                   }),
@@ -643,10 +643,8 @@ export default class Gateway extends Internal implements IGateway {
                                 jsonrpc: '2.0',
                                 id,
                                 result,
-                                ...((resultMeta as {checkpoints?: unknown[]})?.checkpoints
-                                    ?.length && {
-                                    checkpoints: (resultMeta as {checkpoints?: unknown[]})
-                                        .checkpoints,
+                                ...((resultMeta as {progress?: unknown[]})?.progress?.length && {
+                                    progress: (resultMeta as {progress?: unknown[]}).progress,
                                 }),
                             };
                         }

package/src/RpcClient.ts

@@ -195,9 +195,9 @@ export default class RpcClientImpl extends RemoteImpl implements IRpcClient {
                         const result = await decode(body.result);
                         if (/\.service\.get$/.test(method!))
                             Object.assign((result as Record<string, unknown>[])[0], requestParams);
-                        if ((body as unknown as {checkpoints?: unknown[]}).checkpoints?.length) {
-                            ((callerMeta as {checkpoints?: unknown[]}).checkpoints ??= []).push(
-                                ...(body as unknown as {checkpoints: unknown[]}).checkpoints,
+                        if ((body as unknown as {progress?: unknown[]}).progress?.length) {
+                            ((callerMeta as {progress?: unknown[]}).progress ??= []).push(
+                                ...(body as unknown as {progress: unknown[]}).progress,
                             );
                         }
                         return result;

package/src/RpcServer.ts

@@ -85,8 +85,8 @@ export default class RpcServer extends Internal implements IRpcServer {
                 jsonrpc: '2.0',
                 id,
                 result,
-                ...((newMeta as {checkpoints?: unknown[]}).checkpoints?.length && {
-                    checkpoints: (newMeta as {checkpoints?: unknown[]}).checkpoints,
+                ...((newMeta as {progress?: unknown[]}).progress?.length && {
+                    progress: (newMeta as {progress?: unknown[]}).progress,
                 }),
             };
         }

package/src/SemanticLog.test.ts

@@ -324,7 +324,17 @@ t.test('every level is bound, and emits at its own level', async t => {
     // `fatal` is written synchronously, so it is staged rather than stored: it is
     // the one level whose record survives an exit that drains no I/O, and it
     // reaches the store on the next open. The other five take the queued path.
-    t.same(levels.sort(), ['debug', 'error', 'info', 'trace', 'warn']);
+    //
+    // An error appears twice, and that is the tenant model rather than a duplicate
+    // write: every record is stored once under its **shape** (keyed by the shape
+    // reference, standing for every occurrence of it), and a record whose denoise
+    // would hide something — an error, or one that withheld a payload — is stored
+    // under its own id as well, because that occurrence is what is being diagnosed.
+    t.same(
+        levels.sort(),
+        ['debug', 'error', 'error', 'info', 'trace', 'warn'],
+        'every level is stored, and the error under its shape and its own id',
+    );
     const staged = readFileSync(cachePaths.sidecarFile(dir), 'utf8')
         .trim()
         .split('\n')
@@ -332,8 +342,8 @@ t.test('every level is bound, and emits at its own level', async t => {
         .map(entry => JSON.parse(entry.json) as {levelName: string});
     t.same(
         staged.map(entry => entry.levelName),
-        ['fatal'],
-        'the fatal record is staged, not stored',
+        ['fatal', 'fatal'],
+        'the fatal record is staged under its shape and its own id, and never stored',
     );
     await cache.close();
 });

package/src/SemanticLog.ts

@@ -85,7 +85,7 @@ export interface SemanticLogConfig {
     /**
      * Retain records on disk so a printed reference resolves later. The directory is
      * the framework's log cache, which the pino transport also writes — one store,
-     * shared, so a `semantic-log://record/<id>` reference resolves whichever
+     * shared, so a `semlog://r/<id>` reference resolves whichever
      * implementation emitted it.
      */
     cache?: RetentionOptions;

package/src/Watch.ts

@@ -22,6 +22,12 @@ import type {Dirent} from 'node:fs';
 import merge from 'ut-function.merge';
 
 import layerProxy from './layerProxy.ts';
+// The chain is server-side code — it pulls `node:assert` and the event emitter the test
+// executor is built on — so only its types may be imported statically: a value import
+// puts the chain in the browser's eager module graph, where linking its `node:events`
+// import fails before a single handler runs. The Allure session is ended through a
+// dynamic import for the same reason.
+import type {IAllureRunOptions} from './chain.ts';
 import {runInFlow, withStep} from './semanticContext.ts';
 
 export interface IWatch {
@@ -82,6 +88,8 @@ interface IConfig {
     ignored: string[];
     configs: string[];
     logLevel: Parameters<ILog['logger']>[0];
+    /** Allure reporting options, as the framework config supplies them. */
+    allure?: IAllureRunOptions;
 }
 
 // ---------------------------------------------------------------------------
@@ -115,6 +123,7 @@ export default class Watch extends Internal implements IWatch {
         ignored: [],
         configs: [],
         logLevel: 'debug',
+        allure: undefined,
     };
 
     #handlerFolders: Map<string, {name: string; pkg: IModuleConfig['pkg']; base: string}> =
@@ -739,10 +748,6 @@ export default class Watch extends Internal implements IWatch {
                     test?: unknown;
                 };
                 try {
-                    const chain = await (
-                        await import('./chain.ts')
-                    ).default(test as ITestContext, this.log);
-
                     const groups = ([] as string[]).concat(this.#config.test);
                     let executed = 0;
                     await withProgress(
@@ -763,6 +768,22 @@ export default class Watch extends Internal implements IWatch {
                                 // were then made in no flow at all, and the observed flow the
                                 // run was supposed to leave behind never existed.
                                 const meta: IMeta = {mtid: 'event', method};
+                                // The chain is built per group because it carries the
+                                // group's wire name: Allure labels come from it, and the
+                                // result's own name is the group's display name, which is
+                                // set on the steps just below.
+                                const chain = await (
+                                    await import('./chain.ts')
+                                ).default(test as ITestContext, this.log, {
+                                    method,
+                                    allure: this.#config.allure,
+                                    // The Allure integration writes files, which a browser
+                                    // platform has nowhere to do: the platform is handed over
+                                    // so the chain can explain the report a browser run asked
+                                    // for and cannot have, instead of failing to import its
+                                    // way to the same end once per group.
+                                    platform: this.#platform.platform,
+                                });
                                 await runInFlow(meta, method, async () => {
                                     const steps = await remote.remote(method)({}, meta);
                                     if (Array.isArray(steps) && !('name' in steps)) {
@@ -795,6 +816,14 @@ export default class Watch extends Internal implements IWatch {
                     this.log?.error?.(error);
                     done?.(error);
                     return;
+                } finally {
+                    // The results directory belongs to the run, not to any one group,
+                    // so the session closes once every group has reported. The chain is
+                    // imported here rather than at the top of the file so that a
+                    // platform which never runs a group never links it.
+                    await (await import('./chain.ts'))
+                        .endAllureSession()
+                        .catch(error => this.log?.error?.(error));
                 }
                 done?.();
             });

package/src/browserEagerImports.test.ts

@@ -0,0 +1,62 @@
+import {readFileSync, readdirSync} from 'node:fs';
+import {dirname, join} from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {test} from 'tap';
+
+// ---------------------------------------------------------------------------
+// Node-only modules must not be imported for a value.
+//
+// A browser build stubs what it cannot resolve and carries on, so an eager import of a
+// node-only module survives CI and only shows up in a teardown-free dev server: vite
+// links the module graph before any code runs and refuses a *named* import from its
+// browser-external stub, which takes the whole page down ("The requested module
+// '/@id/__vite-browser-external:node:events' does not provide an export named
+// 'EventEmitter'"). The browser entry reaches `Watch.ts` through a dynamic import the
+// loader executes at startup, so a static import inside it is as eager as one made by
+// the entry itself — this scans the sources rather than a bundle because a dynamic edge
+// hides the module from a bundler's static view.
+// ---------------------------------------------------------------------------
+
+const srcDir = dirname(fileURLToPath(import.meta.url));
+
+interface INodeOnlyModule {
+    /** Import specifier as written in the sources. */
+    specifier: string;
+    /** What makes it unusable in a browser. */
+    reason: string;
+}
+
+const NODE_ONLY: INodeOnlyModule[] = [
+    {
+        specifier: './chain.ts',
+        reason: 'it needs node:assert, node:test and the event emitter its executor extends',
+    },
+];
+
+/** `import x from '...'`, `export {x} from '...'` and side-effect imports, but not `import type`. */
+const eagerImport = (specifier: string) =>
+    new RegExp(
+        `^\\s*(?:import|export)\\s+(?!type\\s)[^;]*?from\\s*['"]${specifier}['"]|^\\s*import\\s*['"]${specifier}['"]`,
+        'gm',
+    );
+
+test('a node-only module is never imported for a value', async t => {
+    const files = readdirSync(srcDir).filter(
+        name => name.endsWith('.ts') && !name.endsWith('.test.ts'),
+    );
+    t.ok(files.length > 0, 'the sources were found');
+
+    for (const {specifier, reason} of NODE_ONLY) {
+        const pattern = eagerImport(specifier);
+        const offenders = files.flatMap(name =>
+            [...readFileSync(join(srcDir, name), 'utf8').matchAll(pattern)].map(
+                match => `${name}: ${match[0].trim()}`,
+            ),
+        );
+        t.same(
+            offenders,
+            [],
+            `${specifier} is imported eagerly (${reason}); import it dynamically, or for its types only:\n      ${offenders.join('\n      ')}`,
+        );
+    }
+});

package/src/chain.allure.test.ts

@@ -0,0 +1,216 @@
+/**
+ * What the chain runner does with Allure reporting when it cannot have it.
+ *
+ * Allure 3's format is a directory of files, so the integration needs a filesystem.
+ * A browser platform has none, and the lazy import of `blong-allure` there can only
+ * fail — which the runner used to discover once per group, leaving a run with no
+ * results and no explanation of why. These tests pin the two halves of the fix: the
+ * platform decides *before* the attempt, and the reason is reported once for the run
+ * rather than once per group.
+ *
+ * Each test imports the module fresh: the session, the run's options and the reason
+ * it cannot report are module-level state, and a test that inherited them from the
+ * one before it would be asserting the previous test's outcome.
+ */
+
+import {existsSync} from 'node:fs';
+import {mkdtemp, readdir, readFile, rm} from 'node:fs/promises';
+import {tmpdir} from 'node:os';
+import {join} from 'node:path';
+import {test} from 'tap';
+
+/** A test context that runs what it is given, the way the runner's own does. */
+interface IContext {
+    test: (name: string, fn: (t: IContext) => unknown) => Promise<unknown>;
+}
+
+function contextAt(): IContext {
+    return {
+        test: async (_name: string, fn: (t: IContext) => unknown) => fn(contextAt()),
+    };
+}
+
+/** A group's steps, named the way the runner names them from the wire name. */
+function group(name: string, steps: Array<() => unknown>): Array<() => unknown> {
+    const wrapped = [...steps];
+    Object.defineProperty(wrapped, 'name', {value: name});
+    return wrapped;
+}
+
+/** The log the runner is handed, recording what a run would have shown a reader. */
+function recordingLog(): {
+    warnings: string[];
+    errors: unknown[];
+    log: {warn: (text: unknown) => void; error: (error: unknown) => void};
+} {
+    const warnings: string[] = [];
+    const errors: unknown[] = [];
+    return {
+        warnings,
+        errors,
+        log: {
+            warn: (text: unknown) => void warnings.push(String(text)),
+            error: (error: unknown) => void errors.push(error),
+        },
+    };
+}
+
+test('a browser run is told why it produces no report, once for the run', async t => {
+    const dir = await mkdtemp(join(tmpdir(), 'blong-chain-allure-'));
+    t.teardown(() => rm(dir, {recursive: true, force: true}));
+    const outputDir = join(dir, 'allure-results');
+    const {warnings, errors, log} = recordingLog();
+    const ran: string[] = [];
+    const {default: chainFactory} = await t.mockImport<typeof import('./chain.ts')>(
+        './chain.ts',
+        {},
+    );
+
+    const chain = await chainFactory(contextAt() as never, log, {
+        method: 'test.order.checkpoint',
+        allure: {enabled: true, outputDir},
+        platform: 'browser',
+    });
+    const run = chain as unknown as (steps: unknown) => Promise<unknown>;
+    await run(
+        group('order checkpoint', [
+            async function loadsOrder() {
+                ran.push('loadsOrder');
+                return 'loaded';
+            },
+        ]),
+    );
+    // A second group, whose own attempt would be a second opportunity to say the
+    // same thing: the answer belongs to the run, so it is said once.
+    await run(
+        group('payment settle', [
+            async function sendsPayment() {
+                ran.push('sendsPayment');
+                return 'sent';
+            },
+        ]),
+    );
+
+    t.same(
+        ran,
+        ['loadsOrder', 'sendsPayment'],
+        'the groups ran: a withheld report is not a withheld test',
+    );
+    t.equal(warnings.length, 1, 'the reader is told once, not once per group');
+    t.match(warnings[0] ?? '', /browser platform cannot write its files/, 'and told the reason');
+    t.match(warnings[0] ?? '', /Allure reporting is enabled/, 'as a configuration mistake');
+    t.same(errors, [], 'nothing failed: the tests are judged on their tests');
+    t.notOk(existsSync(outputDir), 'and no results directory was created');
+
+    // The end of the run closes nothing, because nothing opened: no session means no
+    // import, which on this platform is the one thing that cannot work.
+    await (await import('./chain.ts')).endAllureSession();
+});
+
+test('a server run opens the session and writes the group result', async t => {
+    const dir = await mkdtemp(join(tmpdir(), 'blong-chain-allure-'));
+    t.teardown(() => rm(dir, {recursive: true, force: true}));
+    const outputDir = join(dir, 'allure-results');
+    const {warnings, errors, log} = recordingLog();
+    const {default: chainFactory, endAllureSession} = await t.mockImport<
+        typeof import('./chain.ts')
+    >('./chain.ts', {});
+
+    const chain = await chainFactory(contextAt() as never, log, {
+        method: 'test.order.checkpoint',
+        allure: {enabled: true, outputDir},
+        platform: 'server',
+    });
+    await (chain as unknown as (steps: unknown) => Promise<unknown>)(
+        group('order checkpoint', [
+            async function loadsOrder() {
+                return 'loaded';
+            },
+        ]),
+    );
+
+    t.same(warnings, [], 'a server platform reports nothing and says nothing');
+    t.same(errors, []);
+    const written = await readdir(outputDir);
+    t.ok(
+        written.includes('environment.properties'),
+        'the session laid out its directory, as it does for a real run',
+    );
+    const resultFile = written.find(name => name.endsWith('-result.json'));
+    t.ok(resultFile, 'and the group left a result');
+    const result = JSON.parse(await readFile(join(outputDir, resultFile as string), 'utf8')) as {
+        name?: string;
+        labels?: Array<{name: string; value: string}>;
+    };
+    t.equal(result.name, 'order checkpoint', 'named as the group was run');
+    t.ok(
+        result.labels?.some(label => label.name === 'parentSuite' && label.value === 'test'),
+        'labelled from the group wire name',
+    );
+
+    // The end writes to stdout, which a tap run parses: its line is captured here
+    // rather than left in the middle of the suite's output.
+    const lines: string[] = [];
+    const original = console.log;
+    console.log = (...args: unknown[]) => void lines.push(args.join(' '));
+    try {
+        await endAllureSession();
+    } finally {
+        console.log = original;
+    }
+    t.match(
+        lines.join(''),
+        /Allure results written to/,
+        'the run ends by saying where the results are',
+    );
+
+    // Nothing is left to close: the second end is a no-op rather than a second report.
+    await endAllureSession();
+});
+
+test('a failure to start is reported once, and leaves nothing to close', async t => {
+    const dir = await mkdtemp(join(tmpdir(), 'blong-chain-allure-'));
+    t.teardown(() => rm(dir, {recursive: true, force: true}));
+    const {warnings, errors, log} = recordingLog();
+    let started = 0;
+    let ended = 0;
+    const {default: chainFactory, endAllureSession} = await t.mockImport<
+        typeof import('./chain.ts')
+    >('./chain.ts', {
+        // A server platform that cannot import the integration at all — a package
+        // missing on the runner, say. The runner cannot prevent this one; it can only
+        // say it once and carry on.
+        '@feasibleone/blong-allure': {
+            allureSessionStart: async () => {
+                started += 1;
+                throw new Error('blong-allure is not installed');
+            },
+            allureSessionEnd: async () => {
+                ended += 1;
+            },
+            allureGroupResultWrite: async () => undefined,
+        },
+    });
+
+    const chain = await chainFactory(contextAt() as never, log, {
+        method: 'test.order.checkpoint',
+        allure: {enabled: true, outputDir: join(dir, 'allure-results')},
+        platform: 'server',
+    });
+    const run = chain as unknown as (steps: unknown) => Promise<unknown>;
+    const step = async function loadsOrder() {
+        return 'loaded';
+    };
+    await run(group('order checkpoint', [step]));
+    await run(group('payment settle', [step]));
+
+    t.equal(started, 1, 'one attempt, however many groups ask for a report');
+    t.equal(errors.length, 1, 'and one report of it, not one per group');
+    t.match(String(errors[0]), /blong-allure is not installed/, 'naming what went wrong');
+    t.same(warnings, [], 'an unexpected failure is not a platform refusal');
+
+    // A session that never opened is nothing to close: the end is a no-op, so a run
+    // that could not write results does not also try to generate a report from them.
+    await endAllureSession();
+    t.equal(ended, 0, 'the end of the run closes nothing');
+});