@feasibleone/blong-gogo 1.27.0 → 1.28.0

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # Changelog
 
+## [1.28.0](https://github.com/feasibleone/blong/compare/blong-gogo-v1.27.0...blong-gogo-v1.28.0) (2026-08-19)
+
+
+### Features
+
+* blong-dev log ([88ea53b](https://github.com/feasibleone/blong/commit/88ea53bbe411803a540c3158d151220a1c9bee26))
+* master-detail handling ([03c5bbd](https://github.com/feasibleone/blong/commit/03c5bbd9401a82a9427577e7611f2622aadee4e5))
+* redis adapter and blong-gateway ([c28a68f](https://github.com/feasibleone/blong/commit/c28a68f5f9cfc2398771cca05c4366efc147eb6e))
+* resolve some AI agent frictions ([13ca27f](https://github.com/feasibleone/blong/commit/13ca27f09f0271a25ea7ad45a2ce3f73bf6710e0))
+* resolve some AI agent frictions and improve the framework features ([23b6986](https://github.com/feasibleone/blong/commit/23b69863b458e97f1dad249fcdeec5e182a69b74))
+* self registration ([20f3791](https://github.com/feasibleone/blong/commit/20f3791c453d0f6f4cbf28c2e3af1fbb959a8d0d))
+* update blong-kopi and relevant skills to the latest patterns ([52dacae](https://github.com/feasibleone/blong/commit/52dacae17410933d262637de593bd8dc5db628e8))
+
+
+### Bug Fixes
+
+* improve tooling ([c484c28](https://github.com/feasibleone/blong/commit/c484c28de5ec3e574297b27e49ea42365ea956c1))
+* missing party permissions ([afeb4da](https://github.com/feasibleone/blong/commit/afeb4da93412c0d93da3b2d735471fd3e3a28b27))
+* registry logger ([443a9ed](https://github.com/feasibleone/blong/commit/443a9ed3948a871d42a5c7ff748751ec99ee460b))
+* remove unused functions ([3de9db3](https://github.com/feasibleone/blong/commit/3de9db31032d269cbda9b1e57bc06eec5a3a2061))
+* schema refresh and model list handling ([920e453](https://github.com/feasibleone/blong/commit/920e453f69b9335a07d8c901d042c3d360d4c010))
+* UI issues ([653baaf](https://github.com/feasibleone/blong/commit/653baaf796b20dd4c42ba5be9a2a8be3668e7227))
+* update dependencies ([0f86433](https://github.com/feasibleone/blong/commit/0f86433e1777df5348643e69ecfc28d31dceac35))
+
 ## [1.27.0](https://github.com/feasibleone/blong/compare/blong-gogo-v1.26.0...blong-gogo-v1.27.0) (2026-07-23)
 
 

package/bin/blong-watch.ts

@@ -3,10 +3,16 @@
 import minimist from 'minimist';
 import {existsSync} from 'node:fs';
 import {resolve} from 'node:path';
+import {printUsage, shouldShowHelp} from '../src/cliHelp.ts';
 import {autoRun} from '../src/runServer.ts';
 
 const argv: {_: string[]} = minimist(process.argv.slice(2));
 
+// `--help` / `-h` — short-circuit before autoRun so usage works from any directory.
+if (shouldShowHelp(argv as Record<string, unknown>)) {
+    printUsage(() => process.exit(0));
+}
+
 // The first positional arg is an optional file/folder target; the rest are intents.
 const [maybeTarget, ...rest] = argv._;
 const target = maybeTarget && existsSync(resolve(maybeTarget)) ? resolve(maybeTarget) : undefined;

package/bin/blong.ts

@@ -3,13 +3,62 @@
 import minimist from 'minimist';
 import {existsSync} from 'node:fs';
 import {resolve} from 'node:path';
+import {printUsage, shouldShowHelp} from '../src/cliHelp.ts';
 import {autoRun} from '../src/runServer.ts';
 
-const argv: {_: string[]} = minimist(process.argv.slice(2));
+const rawArgv = minimist(process.argv.slice(2)) as {
+    _: string[];
+    object?: string;
+    [key: string]: unknown;
+};
 
+// `--help` / `-h` — short-circuit before realm-create / autoRun so usage works
+// from any directory (even one without a suite entry point).
+if (shouldShowHelp(rawArgv)) {
+    printUsage(() => process.exit(0));
+}
+
+const {_: positionals, object: objectName} = rawArgv;
+
+// `blong realm <name>` (or `blong create realm <name>`) — scaffold a new realm.
+// `create` is an optional (implied) intent; `realm` selects the creation path.
+// The realm name is the positional following `realm`. This stays within the
+// intent model — no separate subcommand — so the target-vs-intents parsing is
+// untouched for every other invocation.
+const isRealmCreate =
+    positionals.includes('realm') &&
+    // If one of the positionals is an existing path it is a target, not the
+    // realm-creation intent.
+    !positionals.some(p => existsSync(resolve(p)));
+if (isRealmCreate) {
+    const realmIdx = positionals.indexOf('realm');
+    const realmName = positionals[realmIdx + 1];
+    if (!realmName || realmName === 'create' || realmName === 'realm') {
+        throw new Error(
+            'Usage: blong realm <name> [--object <entity>]   (or: blong create realm <name>)',
+        );
+    }
+    const {createRealm} = await import('../src/kopi.ts');
+    await createRealm(resolve(process.cwd(), realmName), undefined, {object: objectName});
+    // Strip the reserved words (and the consumed `--object` flag) so they never
+    // leak into config intents, then run the freshly scaffolded realm — autoRun
+    // finds its `index.ts` in the new folder.
+    const cleaned = positionals.filter(p => p !== 'realm' && p !== 'create' && p !== realmName);
+    const namedFlags = Object.entries(rawArgv)
+        .filter(([key]) => key !== '_' && key !== 'object')
+        .flatMap(([key, value]) => {
+            if (Array.isArray(value)) return value.map(v => `--${key}=${v}`);
+            if (value === true) return [`--${key}`];
+            return [`--${key}=${value}`];
+        });
+    process.argv = [process.argv[0], process.argv[1], ...cleaned, ...namedFlags];
+    process.chdir(resolve(process.cwd(), realmName));
+}
+
+const parsed = minimist(process.argv.slice(2)) as {_: string[]};
 // The first positional arg is an optional file/folder target; the rest are intents.
-const [maybeTarget, ...rest] = argv._;
+const [maybeTarget, ...rest] = parsed._;
 const target = maybeTarget && existsSync(resolve(maybeTarget)) ? maybeTarget : undefined;
-const intents = target ? rest : argv._;
+const intents = target ? rest : parsed._;
 
 await autoRun({cwd: process.cwd(), target, intents});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@feasibleone/blong-gogo",
-  "version": "1.27.0",
+  "version": "1.28.0",
   "repository": {
     "url": "git+https://github.com/feasibleone/blong.git"
   },
@@ -26,15 +26,15 @@
     "@fastify/cors": "^11.2.0",
     "@fastify/deepmerge": "^3.2.1",
     "@fastify/helmet": "^13.1.0",
-    "@fastify/static": "^10.1.0",
+    "@fastify/static": "^10.1.3",
     "@fastify/swagger": "^9.7.0",
     "@fastify/swagger-ui": "^5.2.5",
     "@fastify/type-provider-typebox": "^6.1.0",
     "@feasibleone/blong": "^1.0.0",
     "@feasibleone/blong-chain": "^1.0.0",
     "@feasibleone/blong-config": "^1.0.0",
-    "@feasibleone/blong-kopi": "^1.0.0",
     "@feasibleone/blong-lib": "^1.0.0",
+    "@feasibleone/blong-mle": "^1.0.0",
     "@feasibleone/blong-mock": "^1.0.0",
     "@keycloak/keycloak-admin-client": "^26.6.2",
     "@kubernetes/client-node": "^1.4.0",
@@ -45,9 +45,10 @@
     "browser-process-hrtime": "^1.0.0",
     "cacache": "^20.0.4",
     "chokidar": "^5.0.0",
-    "fastify": "^5.8.4",
+    "fastify": "^5.11.3",
     "fastify-plugin": "^5.1.0",
     "got": "^14.6.6",
+    "ioredis": "^6.0.0",
     "jose": "^6.2.1",
     "knex": "^3.2.10",
     "ky": "^1.14.2",
@@ -67,13 +68,13 @@
     "tinyglobby": "^0.2.16",
     "typebox": "^1.1.5",
     "ulidx": "^2.4.1",
-    "undici": "^8.0.1",
+    "undici": "^8.10.0",
     "ut-bitsyntax": "^6.2.7",
     "ut-dns-discovery": "^6.2.3",
     "ut-function.cbc": "^1.1.6",
     "ut-function.interpolate": "1.1.3",
     "ut-function.merge": "^1.5.6",
-    "uuid": "^13.0.0",
+    "uuid": "^13.0.2",
     "yaml": "^2.8.3",
     "@feasibleone/blong-template": "1.0.0"
   },
@@ -86,7 +87,7 @@
     "playwright": "^1.60.0",
     "tap": "^21.6.3",
     "typescript": "^6.0.3",
-    "@feasibleone/blong-dev": "1.1.1"
+    "@feasibleone/blong-dev": "1.2.0"
   },
   "scripts": {
     "browser-check": "node scripts/browser-compat-check.mjs",

package/src/ApiGateway.test.ts

@@ -0,0 +1,190 @@
+/**
+ * Tests for the ApiGateway metering plugin — header injection, blocking status
+ * codes, fail-closed 503, and passthrough for non-metered routes — via Fastify
+ * injection (modeled on RestFs.test.ts).
+ */
+
+import assert from 'node:assert';
+import {after, describe, it} from 'node:test';
+
+import fastify, {type FastifyInstance} from 'fastify';
+
+import ApiGateway from './ApiGateway.ts';
+
+type MeterFn = (params: {bundle: string; creditCost: number}, $meta: unknown) => Promise<unknown>;
+
+interface SetupResult {
+    server: FastifyInstance;
+    cleanup: () => Promise<void>;
+}
+
+/**
+ * Build a Fastify instance with the ApiGateway plugin registered plus a
+ * metered route, a non-metered route and an opted-out route.
+ */
+async function setup(
+    meterFn: MeterFn,
+    opts?: {handlerUnavailable?: boolean},
+): Promise<SetupResult> {
+    let capturedPlugin: Parameters<FastifyInstance['register']>[0] | null = null;
+    let capturedOptions: Parameters<FastifyInstance['register']>[1] | null = null;
+    const fakeGateway = {
+        registerPlugin(plugin: typeof capturedPlugin, opts: typeof capturedOptions) {
+            capturedPlugin = plugin;
+            capturedOptions = opts;
+        },
+    };
+    const fakeLocal = {
+        get(_name: string): {method: (...args: unknown[]) => Promise<unknown[]>} | undefined {
+            if (opts?.handlerUnavailable) return undefined;
+            return {
+                method: async (...args: unknown[]) => [
+                    await meterFn(args[0] as {bundle: string; creditCost: number}, args[1]),
+                    undefined,
+                ],
+            };
+        },
+    };
+
+    const apiGateway = new ApiGateway(
+        {
+            enabled: true,
+            meterHandler: 'gateway.meter.check',
+            statusCodes: {rate: 429, credits: 429, subscription: 403},
+        },
+        {gateway: fakeGateway as never, local: fakeLocal as never},
+    );
+    await apiGateway.init();
+
+    const server = fastify();
+    server.addHook('preValidation', (_req, _reply, done) => done());
+    if (capturedPlugin) await server.register(capturedPlugin, capturedOptions!);
+
+    server.route({
+        method: 'POST',
+        url: '/rpc/vision/compute',
+        config: {auth: 'jwt', bundle: 'Vision AI', creditCost: 5},
+        handler: async () => ({success: true, vision: 'computed'}),
+    });
+    server.route({
+        method: 'POST',
+        url: '/rpc/plain/echo',
+        handler: async () => ({ok: true}),
+    });
+    server.route({
+        method: 'POST',
+        url: '/rpc/opt/out',
+        config: {auth: 'jwt', bundle: 'Vision AI', creditCost: 5, meter: false},
+        handler: async () => ({ok: true}),
+    });
+
+    await server.ready();
+    return {server, cleanup: () => server.close()};
+}
+
+const okDecision = {
+    allowed: true,
+    reason: 'ok',
+    creditsRemaining: 995,
+    rateLimit: 100,
+    rateCount: 1,
+    rateResetAt: 123456,
+};
+
+describe('ApiGateway metering plugin', () => {
+    after(() => {});
+
+    it('allows a metered route and injects the rate/credit headers', async () => {
+        const {server, cleanup} = await setup(async () => okDecision);
+        try {
+            const res = await server.inject({method: 'POST', url: '/rpc/vision/compute'});
+            assert.strictEqual(res.statusCode, 200);
+            // Fastify lowercases header names: X-RateLimit-Limit → x-ratelimit-limit
+            assert.strictEqual(res.headers['x-ratelimit-limit'], '100');
+            assert.strictEqual(res.headers['x-ratelimit-remaining'], '99');
+            assert.strictEqual(res.headers['x-credits-remaining'], '995');
+            assert.deepStrictEqual(res.json(), {success: true, vision: 'computed'});
+        } finally {
+            await cleanup();
+        }
+    });
+
+    it('blocks with 429 when the meter denies (rate limit)', async () => {
+        const {server, cleanup} = await setup(async () => ({
+            allowed: false,
+            reason: 'rate',
+            creditsRemaining: -1,
+            rateLimit: 100,
+            rateCount: 101,
+            rateResetAt: 9999,
+        }));
+        try {
+            const res = await server.inject({method: 'POST', url: '/rpc/vision/compute'});
+            assert.strictEqual(res.statusCode, 429);
+            assert.strictEqual(res.headers['retry-after'], '1');
+            assert.strictEqual((res.json() as {error: string}).error, 'rate');
+        } finally {
+            await cleanup();
+        }
+    });
+
+    it('blocks with 403 when the subscription is missing', async () => {
+        const {server, cleanup} = await setup(async () => ({
+            allowed: false,
+            reason: 'subscription',
+            creditsRemaining: -1,
+        }));
+        try {
+            const res = await server.inject({method: 'POST', url: '/rpc/vision/compute'});
+            assert.strictEqual(res.statusCode, 403);
+            assert.strictEqual((res.json() as {error: string}).error, 'subscription');
+        } finally {
+            await cleanup();
+        }
+    });
+
+    it('returns 503 (fail-closed) when the meter handler throws', async () => {
+        const {server, cleanup} = await setup(async () => {
+            throw new Error('Redis unavailable');
+        });
+        try {
+            const res = await server.inject({method: 'POST', url: '/rpc/vision/compute'});
+            assert.strictEqual(res.statusCode, 503);
+            assert.strictEqual((res.json() as {error: string}).error, 'Service Unavailable');
+        } finally {
+            await cleanup();
+        }
+    });
+
+    it('returns 503 (fail-closed) when the meter handler is unavailable', async () => {
+        const {server, cleanup} = await setup(async () => okDecision, {handlerUnavailable: true});
+        try {
+            const res = await server.inject({method: 'POST', url: '/rpc/vision/compute'});
+            assert.strictEqual(res.statusCode, 503);
+        } finally {
+            await cleanup();
+        }
+    });
+
+    it('passes through routes without a bundle config', async () => {
+        const {server, cleanup} = await setup(async () => okDecision);
+        try {
+            const res = await server.inject({method: 'POST', url: '/rpc/plain/echo'});
+            assert.strictEqual(res.statusCode, 200);
+            assert.deepStrictEqual(res.json(), {ok: true});
+        } finally {
+            await cleanup();
+        }
+    });
+
+    it('passes through routes opted out with meter: false', async () => {
+        const {server, cleanup} = await setup(async () => okDecision);
+        try {
+            const res = await server.inject({method: 'POST', url: '/rpc/opt/out'});
+            assert.strictEqual(res.statusCode, 200);
+            assert.deepStrictEqual(res.json(), {ok: true});
+        } finally {
+            await cleanup();
+        }
+    });
+});

package/src/ApiGateway.ts

@@ -0,0 +1,167 @@
+import type {IGateway, ILocal, ILog} from '@feasibleone/blong/types';
+import {Internal} from '@feasibleone/blong/types';
+import type {FastifyInstance, FastifyReply, FastifyRequest} from 'fastify';
+import fp from 'fastify-plugin';
+
+interface IConfig {
+    /**
+     * When false (default) the plugin registers nothing and is a no-op.
+     */
+    enabled: boolean;
+    /**
+     * Handler (semantic triple) that performs metering for a request.
+     * It must accept `{bundle, creditCost}` and return
+     * `{allowed, reason, creditsRemaining, rateLimit, rateCount, rateResetAt}`.
+     */
+    meterHandler: string;
+    /**
+     * HTTP status codes for each blocking reason.
+     */
+    statusCodes: {
+        rate: number;
+        credits: number;
+        subscription: number;
+    };
+}
+
+interface IGatewayWithPlugins extends IGateway {
+    registerPlugin(plugin: unknown, options?: unknown): void;
+}
+
+interface IApiRef {
+    log?: ILog;
+    gateway?: IGatewayWithPlugins;
+    local?: ILocal;
+}
+
+interface IMeterDecision {
+    allowed: boolean;
+    reason: 'ok' | 'rate' | 'credits' | 'subscription';
+    creditsRemaining?: number;
+    rateLimit?: number;
+    rateCount?: number;
+    rateResetAt?: number;
+}
+
+interface IRouteConfig {
+    bundle?: string;
+    creditCost?: number;
+    meter?: boolean;
+    methodName?: string;
+}
+
+export default class ApiGateway extends Internal {
+    #config: IConfig = {
+        enabled: false,
+        meterHandler: 'gateway.meter.check',
+        statusCodes: {
+            rate: 429,
+            credits: 429,
+            subscription: 403,
+        },
+    };
+
+    #apiRef: IApiRef;
+
+    public constructor(config: IConfig, apiRef: IApiRef) {
+        super({log: apiRef.log});
+        this.merge(this.#config, config);
+        this.#apiRef = apiRef;
+    }
+
+    public async init(): Promise<void> {
+        if (!this.#config.enabled || !this.#apiRef.gateway) return;
+
+        const config = this.#config;
+        const apiRef = this.#apiRef;
+        const [subject] = config.meterHandler.split('.');
+        const reqName = `ports.${subject}.request`;
+
+        const plugin = fp(
+            async (server: FastifyInstance) => {
+                // Runs AFTER the jwt plugin (auth + authorize). Metering is the
+                // last gate before the route handler — it does NOT authorize.
+                server.addHook(
+                    'preHandler',
+                    async (request: FastifyRequest, reply: FastifyReply) => {
+                        const routeConfig = request.routeOptions?.config as
+                            | IRouteConfig
+                            | undefined;
+                        // Opt-in per route: only routes that declare a `bundle`
+                        // are metered.  `meter: false` opts a route out.
+                        if (!routeConfig || routeConfig.bundle === undefined) return;
+                        if (routeConfig.meter === false) return;
+
+                        const handler = apiRef.local?.get(reqName);
+                        if (!handler) {
+                            request.log.error(
+                                {meterHandler: config.meterHandler},
+                                'gateway metering handler unavailable',
+                            );
+                            return reply.code(503).send({error: 'Service Unavailable'});
+                        }
+
+                        let result: IMeterDecision;
+                        try {
+                            const [res] = (await handler.method(
+                                {
+                                    bundle: routeConfig.bundle,
+                                    creditCost: routeConfig.creditCost ?? 0,
+                                },
+                                {
+                                    method: config.meterHandler,
+                                    mtid: 'request',
+                                    auth: request.auth?.credentials,
+                                },
+                            )) as [IMeterDecision, unknown];
+                            result = res;
+                        } catch (error) {
+                            // Fail-closed: any metering error (e.g. Redis down)
+                            // blocks the request with 503.
+                            request.log.error({err: error}, 'gateway metering error');
+                            return reply.code(503).send({error: 'Service Unavailable'});
+                        }
+
+                        if (result && typeof result === 'object') {
+                            if (result.rateLimit !== undefined)
+                                reply.header('X-RateLimit-Limit', String(result.rateLimit));
+                            if (result.rateLimit !== undefined && result.rateCount !== undefined) {
+                                reply.header(
+                                    'X-RateLimit-Remaining',
+                                    String(Math.max(0, result.rateLimit - result.rateCount)),
+                                );
+                            }
+                            if (result.creditsRemaining !== undefined)
+                                reply.header(
+                                    'X-Credits-Remaining',
+                                    String(result.creditsRemaining),
+                                );
+                        }
+
+                        if (!result || result.allowed === false) {
+                            const reason = result?.reason ?? 'subscription';
+                            const status =
+                                (config.statusCodes as Record<string, number>)[reason] ?? 429;
+                            if (result?.rateResetAt)
+                                reply.header(
+                                    'Retry-After',
+                                    String(
+                                        Math.max(
+                                            1,
+                                            Math.ceil(result.rateResetAt - Date.now() / 1000),
+                                        ),
+                                    ),
+                                );
+                            return reply
+                                .code(status)
+                                .send({error: reason, message: `request ${reason} blocked`});
+                        }
+                    },
+                );
+            },
+            {name: 'api-gateway'},
+        );
+
+        apiRef.gateway!.registerPlugin(plugin);
+    }
+}

package/src/BrowserLog.ts

@@ -1,4 +1,5 @@
 import {Internal, type ILog, type ILogger} from '@feasibleone/blong/types';
+import {withProgress} from '@feasibleone/blong-lib';
 import type {Level, Logger as PinoLogger} from 'pino';
 
 // ── level constants (bunyan numeric levels) ──────────────────────────────────
@@ -207,6 +208,9 @@ export default class BrowserLog extends Internal implements ILog {
             case 'fatal':
                 result.fatal = child.fatal.bind(child) as ILogger['fatal'];
         }
-        return result;
+        return {
+            ...result,
+            progress: (label, promise, options) => withProgress(result, label, promise, options),
+        };
     }
 }

package/src/Gateway.ts

@@ -156,6 +156,7 @@ export default class Gateway extends Internal implements IGateway {
     #server: ReturnType<typeof fastify> | null = null;
     #resolution: IResolution;
     #log: ILog;
+    #logger: ReturnType<ILog['child']> | undefined;
     #config: IConfig = {
         host: '0.0.0.0',
         port: 8080,
@@ -365,6 +366,9 @@ export default class Gateway extends Internal implements IGateway {
                 config: {
                     auth: value.auth ?? 'jwt',
                     methodName: method,
+                    ...(value.bundle !== undefined && {bundle: value.bundle}),
+                    ...(value.creditCost !== undefined && {creditCost: value.creditCost}),
+                    ...(value.meter !== undefined && {meter: value.meter}),
                 },
                 schema: Type && {
                     ...('body' in value
@@ -558,9 +562,10 @@ export default class Gateway extends Internal implements IGateway {
 
     public async start(): Promise<IGateway> {
         const old = this.#server;
+        this.#logger = this.#log.child({name: 'gateway'}, {level: this.#config.logLevel});
         try {
             this.#server = fastify({
-                loggerInstance: this.#log?.child({name: 'gateway'}, {level: this.#config.logLevel}),
+                loggerInstance: this.#logger,
                 forceCloseConnections: true,
                 ajv: {
                     customOptions: {
@@ -652,6 +657,9 @@ export default class Gateway extends Internal implements IGateway {
         if (this.#manifest && address && typeof address === 'object') {
             this.#manifest.gatewayPort = address.port;
         }
+
+        if (!this.#config.port && !['info', 'debug', 'trace'].includes(this.#config.logLevel ?? ''))
+            this.#logger?.warn?.(`gateway listening at random port ${address.port}`);
         return this;
     }
 

package/src/Log.ts

@@ -1,5 +1,6 @@
+import {withProgress} from '@feasibleone/blong-lib';
 import {Internal, type ILog, type ILogger} from '@feasibleone/blong/types';
-import {pino, type LogFn, type Logger, type LoggerOptions} from 'pino';
+import {pino, type Logger, type LoggerOptions} from 'pino';
 import {monotonicFactory} from 'ulidx';
 import type {CacacheTransportOptions} from './pino-cacache.js';
 
@@ -28,14 +29,31 @@ const ignoreArgPatterns = [
 // execArgv to [], stripping the TypeScript loader.  We work around this by
 // explicitly forwarding process.execArgv so the TypeScript loader is available
 // inside the transport worker thread.
+//
+// However, when the process is started under `tap` (e.g. `blong-dev test`),
+// process.execArgv contains tap's own `--import` hooks (@tapjs/typescript →
+// pirates/ts-node). Those hooks intercept `.ts` loads in the worker and bypass
+// Node's native type stripping, which fails on `import type` constructs
+// (SyntaxError: Unexpected identifier 'PinoPretty' in pino-pretty.ts). So we
+// drop tap's hooks from the worker execArgv.
+//
+// Dropping the hooks alone is not enough: pino's multi-target transport loads
+// `.ts`/`.cts` targets with `realRequire()` (CJS require, relying on ts-node),
+// which fails regardless of execArgv. We therefore point both transports at
+// tiny `.mjs` shims (pino-pretty.mjs / pino-cacache.mjs) that re-export the
+// `.ts` modules. Pino then treats them as non-TypeScript targets and loads
+// them with `realImport()` (dynamic ESM import), where Node's native type
+// stripping handles the re-exported `.ts` — in both tap and normal dev runs.
 const WORKER_OPTS = {
     execArgv: process.execArgv.filter(
-        arg => !ignoreArgPatterns.some(pattern => arg.startsWith(pattern)),
+        arg =>
+            !ignoreArgPatterns.some(pattern => arg.startsWith(pattern)) &&
+            !(arg.startsWith('--import=') && arg.includes('@tapjs')),
     ),
 };
 
 const PRETTY_TRANSPORT = {
-    target: './pino-pretty.ts',
+    target: './pino-pretty.mjs',
     worker: WORKER_OPTS,
     options: {
         singleLine: true,
@@ -77,7 +95,7 @@ export default class Log extends Internal implements ILog {
                 targets: [
                     PRETTY_TRANSPORT,
                     {
-                        target: './pino-cacache.ts',
+                        target: './pino-cacache.mjs',
                         worker: WORKER_OPTS,
                         options: cacacheOptions,
                     },
@@ -99,13 +117,13 @@ export default class Log extends Internal implements ILog {
         bindings: object,
     ): ReturnType<ILog['logger']> {
         const child = this.#logger.child(bindings, {level});
-        const result: Record<keyof ILogger, LogFn | null> = {
-            trace: null,
-            debug: null,
-            info: null,
-            warn: null,
-            error: null,
-            fatal: null,
+        const result: ILogger = {
+            trace: undefined,
+            debug: undefined,
+            info: undefined,
+            warn: undefined,
+            error: undefined,
+            fatal: undefined,
         };
         switch (level) {
             case 'trace':
@@ -121,6 +139,9 @@ export default class Log extends Internal implements ILog {
             case 'fatal':
                 result.fatal = child.fatal.bind(child);
         }
-        return result as unknown as ILogger;
+        return {
+            ...result,
+            progress: (label, promise, options) => withProgress(result, label, promise, options),
+        };
     }
 }