@feasibleone/blong-gogo 1.15.0 → 1.17.0

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # Changelog
 
+## [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)
+
+
+### Features
+
+* implement ConfigRuntime for hot configuration reload ([#115](https://github.com/feasibleone/blong/issues/115)) ([61bab7c](https://github.com/feasibleone/blong/commit/61bab7ce8587bf83d72fe80138aaef68943f21c4))
+* unified test and handlers ([#117](https://github.com/feasibleone/blong/issues/117)) ([bf0ed96](https://github.com/feasibleone/blong/commit/bf0ed96c5df3d949fa225dd8a30fc25698a7855a))
+
 ## [1.15.0](https://github.com/feasibleone/blong/compare/blong-gogo-v1.14.3...blong-gogo-v1.15.0) (2026-03-29)
 
 

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,17 @@
 {
   "name": "@feasibleone/blong-gogo",
-  "version": "1.15.0",
+  "version": "1.17.0",
   "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": {
     "blong": "./bin/blong.ts",
@@ -39,6 +44,7 @@
     "glob": "^13.0.6",
     "got": "^14.6.6",
     "jose": "^6.2.1",
+    "undici": "^8.0.1",
     "knex": "^3.1.0",
     "ky": "^1.14.2",
     "lru-cache": "^11.2.4",
@@ -69,11 +75,16 @@
     "@rushstack/heft": "^1.2.6",
     "@rushstack/heft-lint-plugin": "^1.2.6",
     "@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": {
     "build": "true",
-    "ci-publish": "node ../../common/scripts/install-run-rush-pnpm.js publish --access public --provenance"
+    "browser-check": "node scripts/browser-compat-check.mjs",
+    "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;
+    }
+}