@feasibleone/blong-gogo 1.16.0 → 1.17.1

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## [1.17.1](https://github.com/feasibleone/blong/compare/blong-gogo-v1.17.0...blong-gogo-v1.17.1) (2026-04-10)
+
+
+### Bug Fixes
+
+* build ([32951e4](https://github.com/feasibleone/blong/commit/32951e46561648651ee4e032545655007c05e274))
+
+## [1.17.0](https://github.com/feasibleone/blong/compare/blong-gogo-v1.16.0...blong-gogo-v1.17.0) (2026-04-10)
+
+
+### Features
+
+* auto-discover and run blong from a folder with loose handler files ([#120](https://github.com/feasibleone/blong/issues/120)) ([4b407b6](https://github.com/feasibleone/blong/commit/4b407b6d0888eed0bb6cdc8428d82ed15f5152c5))
+* **blong-gogo:** browser compatibility — replace got/tls with ky+undici, add BrowserLog, static tree-shaking split ([#123](https://github.com/feasibleone/blong/issues/123)) ([91b8d1a](https://github.com/feasibleone/blong/commit/91b8d1a159463f9e5a0f4f6d52c4c285989cac43))
+* blong-ui ([9ca1281](https://github.com/feasibleone/blong/commit/9ca1281c0178c69dfc722bc4a5978f649bc1fa0d))
+* improve logging ([5f43391](https://github.com/feasibleone/blong/commit/5f43391a43a99e0dd591401e24c45cd02b3bdba2))
+* simplify api loading ([e6ff342](https://github.com/feasibleone/blong/commit/e6ff34239d7f1f53e3a21d30768ed5ab45042786))
+
+
+### Bug Fixes
+
+* bin deduplicate ([af41171](https://github.com/feasibleone/blong/commit/af41171c0c4dbb0599f7bbe1c82efc4923fd79c8))
+
 ## [1.16.0](https://github.com/feasibleone/blong/compare/blong-gogo-v1.15.0...blong-gogo-v1.16.0) (2026-04-01)
 
 

package/bin/blong-dev.ts

@@ -1,47 +1,8 @@
 #!/usr/bin/env -S node --watch --inspect
 
 import minimist from 'minimist';
-import {existsSync} from 'node:fs';
-import {basename, resolve} from 'node:path';
-import load from '../src/load.ts';
+import {autoRun} from '../src/loadServer.ts';
 
 const argv: {_: string[]} = minimist(process.argv.slice(2));
-const cwd = process.cwd();
-const target = argv._[0];
 
-if (target) {
-    // Explicit file provided — load it directly (existing behavior)
-    (await import(resolve(target))).default(load);
-} else {
-    // Auto-detect what to run based on available files in the current directory.
-    const indexFile = resolve(cwd, 'index.ts');
-    const serverFile = resolve(cwd, 'server.ts');
-    const browserFile = resolve(cwd, 'browser.ts');
-
-    if (existsSync(indexFile)) {
-        (await import(indexFile)).default(load);
-    } else if (existsSync(serverFile) && existsSync(browserFile)) {
-        const {default: server} = await import(serverFile);
-        const {default: browser} = await import(browserFile);
-        const name = basename(cwd);
-        const platforms: Awaited<ReturnType<typeof load>>[] = await Promise.all([
-            load(server, name, name, ['microservice', 'integration', 'dev']),
-            load(browser, name, name, ['microservice', 'integration', 'dev']),
-        ]);
-        for (const platform of platforms) await platform.start();
-        await platforms[1].test();
-        if (process.env.CI) for (const platform of platforms) await platform.stop();
-    } else if (existsSync(serverFile)) {
-        const {default: server} = await import(serverFile);
-        const name = basename(cwd);
-        const platform = await load(server, name, name, ['microservice', 'integration', 'dev']);
-        await platform.start();
-        await platform.test();
-        if (process.env.CI) await platform.stop();
-    } else {
-        throw new Error(
-            `No index.ts, server.ts, or browser.ts found in ${cwd}. ` +
-                'Run blong from a suite or realm folder, or provide a file path.',
-        );
-    }
-}
+await autoRun({cwd: process.cwd(), target: argv._[0]});

package/bin/blong.ts

@@ -1,48 +1,8 @@
 #!/usr/bin/env -S node
 
 import minimist from 'minimist';
-import { existsSync } from 'node:fs';
-import { basename, join, resolve } from 'node:path';
-import load from '../src/load.ts';
+import {autoRun} from '../src/loadServer.ts';
 
 const argv: {_: string[]} = minimist(process.argv.slice(2));
-const cwd = process.cwd();
-const target = argv._[0];
 
-if (target) {
-    // Explicit file provided — load it directly
-    (await import(resolve(target))).default(load);
-} else {
-    const indexFile = join(cwd, 'index.ts');
-    const serverFile = join(cwd, 'server.ts');
-    const browserFile = join(cwd, 'browser.ts');
-    const name = basename(cwd);
-
-    if (existsSync(indexFile)) {
-        // index.ts exists — use it directly (suite or realm with a custom runner)
-        (await import(indexFile)).default(load);
-    } else if (existsSync(serverFile) && existsSync(browserFile)) {
-        // Both server.ts and browser.ts — two-platform (suite or realm with browser)
-        const {default: serverDef} = await import(serverFile);
-        const {default: browserDef} = await import(browserFile);
-        const platforms: Awaited<ReturnType<typeof load>>[] = await Promise.all([
-            load(serverDef, name, name, ['microservice', 'integration', 'dev']),
-            load(browserDef, name, name, ['microservice', 'integration', 'dev']),
-        ]);
-        for (const platform of platforms) await platform.start();
-        await platforms[1].test();
-        if (process.env.CI) for (const platform of platforms) await platform.stop();
-    } else if (existsSync(serverFile)) {
-        // Only server.ts — suite or realm (loadRealm detects and wraps realms automatically)
-        const {default: serverDef} = await import(serverFile);
-        const platform = await load(serverDef, name, name, ['microservice', 'integration', 'dev']);
-        await platform.start();
-        await platform.test();
-        if (process.env.CI) await platform.stop();
-    } else {
-        throw new Error(
-            `No index.ts or server.ts found in ${cwd}. ` +
-                'Run blong from a suite or realm folder, or provide a file path.',
-        );
-    }
-}
+await autoRun({cwd: process.cwd(), target: argv._[0]});

package/package.json

@@ -1,12 +1,16 @@
 {
   "name": "@feasibleone/blong-gogo",
-  "version": "1.16.0",
+  "version": "1.17.1",
   "repository": {
     "url": "git+https://github.com/feasibleone/blong.git"
   },
   "type": "module",
   "exports": {
-    ".": "./src/load.ts",
+    ".": {
+      "browser": "./src/browser.ts",
+      "import": "./src/load.ts"
+    },
+    "./browser": "./src/adapter/browser.ts",
     "./ConfigRuntime.js": "./src/ConfigRuntime.ts"
   },
   "bin": {
@@ -16,7 +20,7 @@
   },
   "dependencies": {
     "@apidevtools/swagger-parser": "^12.1.0",
-    "@aws-sdk/client-s3": "^3.1003.0",
+    "@aws-sdk/client-s3": "^3.1028.0",
     "@fastify/basic-auth": "^6.2.0",
     "@fastify/bearer-auth": "^10.1.2",
     "@fastify/cookie": "^11.0.2",
@@ -35,7 +39,7 @@
     "ajv-formats": "^3.0.1",
     "browser-process-hrtime": "^1.0.0",
     "chokidar": "^5.0.0",
-    "fastify": "^5.8.2",
+    "fastify": "^5.8.4",
     "fastify-plugin": "^5.1.0",
     "glob": "^13.0.6",
     "got": "^14.6.6",
@@ -56,6 +60,7 @@
     "reconnect-core": "^1.3.0",
     "typebox": "^1.1.5",
     "ulidx": "^2.4.1",
+    "undici": "^8.0.1",
     "ut-bitsyntax": "^6.2.7",
     "ut-dns-discovery": "^6.2.3",
     "ut-function.interpolate": "1.1.3",
@@ -63,7 +68,7 @@
     "ut-function.timing": "^1.2.0",
     "ut-port": "^6.45.2",
     "uuid": "^13.0.0",
-    "yaml": "^2.8.2"
+    "yaml": "^2.8.3"
   },
   "devDependencies": {
     "@rushstack/eslint-config": "^4.6.4",
@@ -72,10 +77,12 @@
     "@rushstack/heft-typescript-plugin": "^1.3.1",
     "@types/node": "^24",
     "eslint": "~9.39.2",
+    "playwright": "^1.58.2",
     "tap": "^21.6.2",
     "typescript": "^5.9.3"
   },
   "scripts": {
+    "browser-check": "node scripts/browser-compat-check.mjs",
     "build": "true",
     "ci-publish": "node ../../common/scripts/install-run-rush-pnpm.js publish --access public --provenance",
     "ci-unit": "tap src/ConfigRuntime.test.ts src/lib.test.ts --allow-incomplete-coverage"

package/src/BrowserLog.ts

@@ -0,0 +1,144 @@
+import {Internal, type ILog} from '@feasibleone/blong/types';
+import {pino, type Level, type Logger, type LoggerOptions} from 'pino';
+
+// ── level constants (pino uses numeric levels matching bunyan) ──────────────
+const TRACE = 10, DEBUG = 20, INFO = 30, WARN = 40, ERROR = 50, FATAL = 60;
+
+const nameFromLevel: Record<number, string> = {
+    [TRACE]: 'trace', [DEBUG]: 'debug', [INFO]: 'info',
+    [WARN]: 'warn', [ERROR]: 'error', [FATAL]: 'fatal',
+};
+
+const LEVEL_CSS: Record<string, string> = {
+    trace: 'color: grey',
+    debug: 'color: blue',
+    info:  'color: cyan',
+    warn:  'color: magenta',
+    error: 'color: red',
+    fatal: 'color: red; font-weight: bold',
+};
+const DEFAULT_CSS = {
+    def:     'color: black',
+    msg:     'color: darkblue',
+    service: 'color: darkorange',
+    mtid:    'color: Magenta',
+    src:     'color: DimGray; font-style: italic; font-size: 0.9em',
+};
+
+// Fields written separately; everything else goes into the `details` object
+const SKIP = new Set([
+    'name', 'hostname', 'pid', 'level', 'component', 'msg', 'time', 'v',
+    'src', 'error', 'clientReq', 'clientRes', 'req', 'res',
+    '$meta', 'mtid', 'jsException', 'service',
+]);
+
+export interface IBrowserLogConfig {
+    level?: Level;
+    /** Route each log call to the matching console.warn / console.error etc.
+     *  instead of always using console.log. Default: false */
+    logByLevel?: boolean;
+}
+
+function write(rec: Record<string, unknown>, logByLevel: boolean): void {
+    const level = rec.level as number;
+    const levelKey = nameFromLevel[level] ?? 'info';
+    const paddedLevel = levelKey.toUpperCase().padStart(5);
+
+    // Choose the console method
+    let consoleMethod: (...a: unknown[]) => void = console.log; // eslint-disable-line no-console
+    if (logByLevel) {
+        const mapped = level <= TRACE ? 'debug' : level >= FATAL ? 'error' : levelKey;
+        consoleMethod = (typeof (console as Record<string, unknown>)[mapped] === 'function'
+            ? (console as Record<string, (...a: unknown[]) => void>)[mapped]
+            : console.log); // eslint-disable-line no-console
+    }
+
+    const levelCss =
+        level < DEBUG ? LEVEL_CSS.trace :
+        level < INFO  ? LEVEL_CSS.debug :
+        level < WARN  ? LEVEL_CSS.info  :
+        level < ERROR ? LEVEL_CSS.warn  :
+        level < FATAL ? LEVEL_CSS.error : LEVEL_CSS.fatal;
+
+    // any fields not in the skip list become the expandable details object
+    const details: Record<string, unknown> = {};
+    for (const [k, v] of Object.entries(rec)) {
+        if (v != null && !SKIP.has(k)) details[k] = v;
+    }
+    const hasDetails = Object.keys(details).length > 0;
+
+    const loggerName = rec.childName
+        ? `${rec.name}/${rec.childName}`
+        : (rec.name as string | undefined) ?? '';
+
+    const time = rec.time instanceof Date
+        ? rec.time.toISOString().slice(11, 23)
+        : new Date().toISOString().slice(11, 23);
+
+    const label =
+        (rec.$meta as Record<string, string> | undefined)?.method ??
+        (rec.$meta as Record<string, string> | undefined)?.opcode ??
+        (rec.msg as string | undefined) ?? '';
+
+    const fmt = `[%s] %c%s%c %s%c %s: %c%s %c%s${hasDetails ? ' %c%o' : ''}`;
+    const args: unknown[] = [
+        fmt,
+        time,
+        levelCss,    paddedLevel,
+        DEFAULT_CSS.service,  rec.service ?? '',
+        DEFAULT_CSS.def,      loggerName,
+        DEFAULT_CSS.mtid,     (rec.mtid as string | undefined) ?? '',
+        DEFAULT_CSS.msg,      label,
+    ];
+    if (hasDetails) args.push(DEFAULT_CSS.src, details);
+
+    consoleMethod(...args);
+
+    if (rec.error && (rec.error as {stack?: string}).stack)
+        console.error(rec.error); // eslint-disable-line no-console
+}
+
+export default class BrowserLog extends Internal implements ILog {
+    #logger: Logger;
+    #config: IBrowserLogConfig = {level: 'info', logByLevel: false};
+
+    public constructor(config: IBrowserLogConfig) {
+        super();
+        this.merge(this.#config, config);
+        const logByLevel = this.#config.logByLevel ?? false;
+        this.#logger = pino({
+            level: this.#config.level ?? 'info',
+            browser: {
+                asObject: true,
+                write: (rec: Record<string, unknown>) => write(rec, logByLevel),
+            },
+        });
+    }
+
+    public child<T extends string>(...params: Parameters<Logger<never>['child']>): Logger<T> {
+        return this.#logger.child(...params) as Logger<T>;
+    }
+
+    public logger(
+        level: LoggerOptions['level'] = this.#config.level,
+        bindings: object,
+    ): ReturnType<ILog['logger']> {
+        const child = this.#logger.child(bindings, {level});
+        const result = {trace: null, debug: null, info: null, warn: null, error: null, fatal: null};
+        switch (level) {
+            case 'trace':
+                result.trace = child.trace.bind(child);
+            case 'debug': // eslint-disable-line no-fallthrough
+                result.debug = child.debug.bind(child);
+            case 'info': // eslint-disable-line no-fallthrough
+                result.info = child.info.bind(child);
+            case 'warn': // eslint-disable-line no-fallthrough
+                result.warn = child.warn.bind(child);
+            case 'error': // eslint-disable-line no-fallthrough
+                result.error = child.error.bind(child);
+            case 'fatal': // eslint-disable-line no-fallthrough
+                result.fatal = child.fatal.bind(child);
+        }
+        return result;
+    }
+}

package/src/Realm.ts

@@ -17,16 +17,21 @@ export default class RealmImpl implements IRealm {
 
     public constructor(
         config: {
-            realm?: {logLevel?: Parameters<ILog['logger']>[0]};
+            server: {realm: {logLevel: Parameters<ILog['logger']>[0]}};
+            browser: {realm: {logLevel: Parameters<ILog['logger']>[0]}};
             name: string;
             pkg: {name: string; version: string};
         },
         {log, registry}: {log?: ILog; registry?: IRegistry},
+        platform: 'server' | 'browser',
     ) {
         this.#config = config;
         this.#registry = registry;
         this.#log = log;
-        this.#logger = this.#log?.logger(config.realm?.logLevel, {name: 'realm'});
+        this.#logger = this.#log?.logger(config[platform]?.realm?.logLevel, {
+            name: config.name,
+            context: `${platform}`,
+        });
     }
 
     private _addModuleInternal(name: string | symbol, mod: IRegistry): void {
@@ -39,7 +44,10 @@ export default class RealmImpl implements IRealm {
     }
 
     public addModule(name: string, mod: IRegistry): void {
-        this.#logger?.debug?.(`Module ${this.#config.name}.${name}`);
+        this.#logger?.debug?.(
+            {$meta: {mtid: 'event', method: 'module.add'}},
+            `${this.#config.name}.${name}`,
+        );
         this._addModuleInternal(name, mod);
     }
 
@@ -58,8 +66,16 @@ export default class RealmImpl implements IRealm {
             }
         });
         if (source.length === 1)
-            this.#logger?.debug?.(`Layer ${this.#config.name}.${layerName} ${source[0]}`);
+            // this.#logger?.debug?.(`Layer ${this.#config.name}.${layerName} ${source[0]}`);
+            this.#logger?.debug?.(
+                {$meta: {mtid: 'event', method: 'layer.add'}},
+                `${this.#config.name}.${layerName} ${source[0]}`,
+            );
         else if (!source.length) this.#logger?.debug?.(`Layer ${this.#config.name}.${layerName}`);
-        else this.#logger?.debug?.({source}, `Layer ${this.#config.name}.${layerName}`);
+        else
+            this.#logger?.debug?.(
+                {$meta: {mtid: 'event', method: 'layer.add'}},
+                `${this.#config.name}.${layerName} ${source}`,
+            );
     }
 }

package/src/Registry.ts

@@ -12,18 +12,18 @@ import type {
     IRemote,
     IRpcServer,
 } from '@feasibleone/blong/types';
-import { Internal } from '@feasibleone/blong/types';
+import {Internal} from '@feasibleone/blong/types';
 import nodeAssert from 'node:assert';
 import PQueue from 'p-queue';
-import { Type } from 'typebox';
-import { monotonicFactory } from 'ulidx';
+import {Type} from 'typebox';
+import {monotonicFactory} from 'ulidx';
 import merge from 'ut-function.merge';
-import { v4 as uuid4, v7 as uuid7 } from 'uuid';
+import {v4 as uuid4, v7 as uuid7} from 'uuid';
 
-import { createAttachCheckpoint } from './checkpoint.ts';
-import { methodId, methodParts } from './lib.ts';
-import type { IResolution } from './Resolution.ts';
-import type { IWatch } from './Watch.ts';
+import {createAttachCheckpoint} from './checkpoint.ts';
+import {methodId, methodParts} from './lib.ts';
+import type {IResolution} from './Resolution.ts';
+import type {IWatch} from './Watch.ts';
 
 type MatchMethodsCallback = (
     name: string,
@@ -103,7 +103,9 @@ export default class Registry extends Internal implements IRegistry {
         this.#log = log;
         this.#watch = watch;
         this.#apiSchema = apiSchema;
-        this.#attachCheckpoint = createAttachCheckpoint(this.#config.checkpointMode ?? 'production');
+        this.#attachCheckpoint = createAttachCheckpoint(
+            this.#config.checkpointMode ?? 'production',
+        );
         this.#rpcServer?.setAttachCheckpoint?.(this.#attachCheckpoint);
     }
 

package/src/Watch.ts

@@ -1,4 +1,5 @@
 import {
+    handler,
     Internal,
     kind,
     type IApiSchema,
@@ -34,6 +35,8 @@ export interface IWatch {
     setConfigRuntime?(configRuntime: ConfigRuntime): void;
 }
 
+const isYaml = (filename: string): boolean => /\.ya?ml$/i.test(filename);
+const isJSON = (filename: string): boolean => /\.jsonl?$/i.test(filename);
 const isCode = (filename: string): boolean => /(?<!\.d)\.m?(t|j)sx?$/i.test(filename);
 const isLayerActivation = (filename: string): boolean =>
     /^layer\.(server|browser)\.[mc]?[tj]sx?$/i.test(filename);
@@ -182,6 +185,7 @@ export default class Watch extends Internal implements IWatch {
         const validations = [];
         const apis = [];
         const libs = [];
+        const assets = [];
         const handlerFilenames = [];
         let latest = 0;
         const allFiles = await scan(dir);
@@ -247,6 +251,17 @@ export default class Watch extends Internal implements IWatch {
                 handlerFilenames.push({name, filename});
             }
         }
+        const assetFiles = allFiles.filter(
+            entry => entry.isFile() && (isYaml(entry.name) || isJSON(entry.name)),
+        );
+        for (const assetFile of assetFiles) {
+            const filename = join(dir, assetFile.name);
+            assets.push(
+                handler(() => ({
+                    assets: {[basename(filename)]: `file://${filename}`},
+                })),
+            );
+        }
         this.#handlerFolders.set(dir, config);
         return api => {
             if (validations.length)
@@ -261,6 +276,12 @@ export default class Watch extends Internal implements IWatch {
                     config.name + '.' + basename(dir) + '.api',
                     relative('.', dir),
                 );
+            if (assets.length)
+                api[basename(dir) + '.asset'](
+                    assets,
+                    config.name + '.' + basename(dir) + '.asset',
+                    relative('.', dir),
+                );
             if (handlers.length)
                 api[basename(dir)](
                     [...libs, ...handlers],

package/src/adapter/browser/http.ts

@@ -1,14 +1,13 @@
 import type {Errors, IErrorMap, IMeta} from '@feasibleone/blong/types';
 import {adapter} from '@feasibleone/blong/types';
-import got, {type HttpsOptions, type Options} from 'got';
-
-import tls from '../../tls.ts';
+import ky, {type Options as KyOptions} from 'ky';
 
 export interface IConfig {
     tls?: {
         key?: string;
         cert?: string;
         ca?: string | string[];
+        crl?: string;
     };
     url?: string;
 }
@@ -22,7 +21,7 @@ let _errors: Errors<typeof errorMap>;
 export default adapter<IConfig>(({utError}) => {
     _errors ||= utError.register(errorMap);
 
-    let https: HttpsOptions;
+    let kyInstance: typeof ky = ky;
     return {
         activation: {
             default: {
@@ -31,7 +30,36 @@ export default adapter<IConfig>(({utError}) => {
         },
         async init(...configs: object[]) {
             await super.init(...configs);
-            https = tls(this.config, true);
+            if (this.config.tls) {
+                // Dynamic imports — only run on the server; @vite-ignore prevents
+                // Vite from trying to bundle these Node.js-only modules for the browser.
+                const [{Agent}, {readFileSync}] = await Promise.all([
+                    import(/* @vite-ignore */ 'undici') as Promise<typeof import('undici')>,
+                    import(/* @vite-ignore */ 'node:fs') as Promise<typeof import('node:fs')>,
+                ]);
+                const {tls} = this.config;
+                const agent = new Agent({
+                    connect: {
+                        minVersion: 'TLSv1.3',
+                        ...(tls.key && {key: readFileSync(tls.key)}),
+                        ...(tls.cert && {cert: readFileSync(tls.cert)}),
+                        ...(tls.ca && {
+                            ca: Array.isArray(tls.ca)
+                                ? tls.ca.map(f => readFileSync(f))
+                                : readFileSync(tls.ca),
+                        }),
+                        ...(tls.crl && {crl: readFileSync(tls.crl)}),
+                    },
+                });
+                kyInstance = ky.create({
+                    fetch: (url, options) =>
+                        fetch(url as string, {
+                            ...(options as RequestInit),
+                            // @ts-expect-error: undici dispatcher is not in the standard RequestInit type
+                            dispatcher: agent,
+                        }),
+                });
+            }
         },
         start() {
             super.connect();
@@ -50,57 +78,56 @@ export default adapter<IConfig>(({utError}) => {
                 json,
             }: {
                 path: string;
-                query: string;
+                query: string | Record<string, string>;
                 url: URL;
-                responseType: Options['responseType'];
-                method: Options['method'];
-                headers: Options['headers'];
-                body: Options['body'];
-                form: Options['form'];
-                json: Options['json'];
+                responseType: 'json' | 'text' | 'buffer';
+                method: string;
+                headers: Record<string, string>;
+                body: BodyInit;
+                form: Record<string, string>;
+                json: unknown;
             },
-            {stream}: IMeta,
+            _meta: IMeta,
         ) {
             try {
                 this.log.debug?.({
                     req: {
-                        method: method.toUpperCase(),
+                        method: (method || 'POST').toUpperCase(),
                         url,
                         headers,
                         body,
                         json,
                     },
                 });
-                const result = (await got({
-                    url,
-                    searchParams,
-                    https,
+                const kyOptions: KyOptions = {
                     method: method || 'POST',
                     headers,
-                    responseType,
-                    body,
-                    form,
-                    json,
                     throwHttpErrors: false,
-                    followRedirect: false,
-                    isStream: !!stream,
-                })) as {
-                    statusCode: number;
-                    statusMessage: string;
-                    headers: Record<string, unknown>;
-                    body: unknown;
+                    redirect: 'manual',
+                    ...(json != null ? {json} : {}),
+                    ...(form != null ? {body: new URLSearchParams(form)} : {}),
+                    ...(body != null && json == null && form == null ? {body} : {}),
+                    ...(searchParams != null ? {searchParams: searchParams as Record<string, string>} : {}),
+                };
+                const res = await kyInstance(url.toString(), kyOptions);
+                const resolvedBody =
+                    responseType === 'buffer'
+                        ? await res.arrayBuffer()
+                        : responseType === 'text'
+                          ? await res.text()
+                          : await res.json().catch(() => null);
+                const result = {
+                    statusCode: res.status,
+                    statusMessage: res.statusText,
+                    headers: Object.fromEntries(res.headers.entries()),
+                    body: resolvedBody,
                 };
                 this.log.debug?.({
                     req: {
                         url,
-                        method: method.toUpperCase(),
-                    },
-                    res: {
-                        statusCode: result.statusCode,
-                        statusMessage: result.statusMessage,
-                        headers: result.headers,
-                        body: result.body,
+                        method: (method || 'POST').toUpperCase(),
                     },
+                    res: result,
                 });
                 return result;
             } catch (error) {