@feasibleone/blong-gogo 1.24.0 → 1.25.1

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # Changelog
 
+## [1.25.1](https://github.com/feasibleone/blong/compare/blong-gogo-v1.25.0...blong-gogo-v1.25.1) (2026-05-25)
+
+
+### Bug Fixes
+
+* dependencies ([cc6ba83](https://github.com/feasibleone/blong/commit/cc6ba830a721dfb063f5331d44e26a97e28c7f9a))
+* improve testing ([2b1d862](https://github.com/feasibleone/blong/commit/2b1d862fda71ed7910bc99f4bbbe11ef17be098c))
+
+## [1.25.0](https://github.com/feasibleone/blong/compare/blong-gogo-v1.24.0...blong-gogo-v1.25.0) (2026-05-19)
+
+
+### Features
+
+* blong-dev ([8eb1aa4](https://github.com/feasibleone/blong/commit/8eb1aa4a8acb6a3dcdd52fb51582e0403efa4064))
+
+
+### Bug Fixes
+
+* lint ([9fa11d1](https://github.com/feasibleone/blong/commit/9fa11d15495a801b63668cb0c8399bae5e9fd6e1))
+* lint ([8cde9a7](https://github.com/feasibleone/blong/commit/8cde9a7b9d54d4556bf33b4f8f61d5c5597ca108))
+* linting ([73ea70a](https://github.com/feasibleone/blong/commit/73ea70a36de49b9c5b0f15d945f52c0eee4cc98f))
+* linting ([27102ca](https://github.com/feasibleone/blong/commit/27102ca91ddf21124439452486a086aa68fc8886))
+* linting ([46d7549](https://github.com/feasibleone/blong/commit/46d7549477c6b863e09972e8c6903a38b5836a8e))
+
 ## [1.24.0](https://github.com/feasibleone/blong/compare/blong-gogo-v1.23.0...blong-gogo-v1.24.0) (2026-05-15)
 
 

package/bin/{blong-dev.ts → blong-watch.ts}

@@ -9,7 +9,7 @@ const argv: {_: string[]} = minimist(process.argv.slice(2));
 
 // The first positional arg is an optional file/folder target; the rest are intents.
 const [maybeTarget, ...rest] = argv._;
-const target = maybeTarget && existsSync(resolve(maybeTarget)) ? maybeTarget : undefined;
+const target = maybeTarget && existsSync(resolve(maybeTarget)) ? resolve(maybeTarget) : undefined;
 const intents = target ? rest : argv._;
 
 await autoRun({cwd: process.cwd(), target, intents});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@feasibleone/blong-gogo",
-  "version": "1.24.0",
+  "version": "1.25.1",
   "repository": {
     "url": "git+https://github.com/feasibleone/blong.git"
   },
@@ -14,8 +14,8 @@
   },
   "bin": {
     "blong": "./bin/blong.ts",
-    "blong-dev": "./bin/blong-dev.ts",
-    "blong-gogo": "./bin/blong-gogo.sh"
+    "blong-gogo": "./bin/blong-gogo.sh",
+    "blong-watch": "./bin/blong-watch.ts"
   },
   "dependencies": {
     "@apidevtools/swagger-parser": "^12.1.0",
@@ -30,7 +30,7 @@
     "@feasibleone/blong-chain": "^1.0.0",
     "@feasibleone/blong-config": "^1.0.0",
     "@feasibleone/blong-kopi": "^1.0.0",
-    "@keycloak/keycloak-admin-client": "^26.5.4",
+    "@keycloak/keycloak-admin-client": "^26.6.2",
     "@kubernetes/client-node": "^1.4.0",
     "@octokit/rest": "^22.0.1",
     "@sinclair/typebox-codegen": "^0.11.1",
@@ -77,14 +77,15 @@
     "@types/node": "^24",
     "playwright": "^1.58.2",
     "tap": "^21.6.3",
-    "typescript": "^5.9.3"
+    "typescript": "^6.0.3",
+    "@feasibleone/blong-dev": "1.0.2"
   },
   "scripts": {
     "browser-check": "node scripts/browser-compat-check.mjs",
     "build": "true",
-    "ci-lint": "tsc --noEmit",
+    "ci-coverage": "./run-coverage.sh",
+    "ci-lint": "blong-dev lint",
     "ci-publish": "node ../../common/scripts/install-run-rush-pnpm.js publish --access public --provenance",
-    "ci-unit": "../common/run-coverage.sh",
-    "ci-coverage": "../common/run-coverage.sh report"
+    "ci-test": "blong-dev test"
   }
 }

package/src/AdapterBase.ts

@@ -177,13 +177,14 @@ export class AdapterBase<T, C extends IContext> implements AdapterHandlerContext
         );
     }
 
-    error(error: ITypedError, $meta: IMeta): void {
+    error(error: ITypedError, $meta: IMeta): ITypedError {
         if ($meta) error.method = $meta.method;
         if (isExpectedError(error.type, $meta?.expect)) {
             (this.log as {debug?: (...args: unknown[]) => void})?.debug?.(error);
-            return;
+            return error;
         }
         (this.log as {error?: (...args: unknown[]) => void})?.error?.(error);
+        return error;
     }
 
     findValidation(): unknown {
@@ -271,7 +272,7 @@ export class AdapterBase<T, C extends IContext> implements AdapterHandlerContext
         return result;
     }
 
-    drain(): void {}
+    async drain(): Promise<void> {}
 
     findHandler(methodName: string): unknown {
         methodName = this._methodId(methodName);
@@ -303,8 +304,8 @@ export class AdapterBase<T, C extends IContext> implements AdapterHandlerContext
         const {req, pub} = this.forNamespaces(
             (
                 prev: {
-                    req: Record<string, (...args: unknown[]) => unknown>;
-                    pub: Record<string, (...args: unknown[]) => unknown>;
+                    req: Record<string, (...args: unknown[]) => Promise<unknown>>;
+                    pub: Record<string, (...args: unknown[]) => Promise<unknown>>;
                 },
                 next,
             ) => {
@@ -318,7 +319,7 @@ export class AdapterBase<T, C extends IContext> implements AdapterHandlerContext
         );
         this._register(req, 'ports', this.config.id, this.config.pkg);
         this._subscribe(pub, 'ports', this.config.id, this.config.pkg);
-        const {context, ...config} = this.config; // eslint-disable-line @typescript-eslint/no-unused-vars
+        const {context: _, ...config} = this.config;
         return this.event('start', {configBase: this.configBase, config});
     }
 

package/src/ApiSchema.ts

@@ -256,7 +256,7 @@ export default handler(
             .join('\n');
     }
 
-    private _paramType(param: {}): string {
+    private _paramType(param: object): string {
         if (!('type' in param)) return 'unknown';
         switch (param.type) {
             case 'string':
@@ -294,7 +294,9 @@ export default handler(
     public async generateFile(filename: string): Promise<boolean> {
         if (this.#config.generate === false) return false;
         if (this.#platform.statSync(filename).size !== 0) return false;
-        let content = this.#platform.readFileSync(filename, {encoding: 'utf-8'}).toString('utf-8');
+        const content = this.#platform
+            .readFileSync(filename, {encoding: 'utf-8'})
+            .toString('utf-8');
         if (content.includes('import unchanged from')) {
             this.#generateFile.add(filename);
             return false;

package/src/ConfigRuntime.test.ts

@@ -92,32 +92,34 @@ test('deepDiff — deeply nested multi-change', async t => {
 
 test('createConfigProxy — reads current values', async t => {
     const store = {db: {host: 'localhost', port: 5432}};
-    const {proxy} = createConfigProxy(store);
-    t.equal((proxy as any).db.host, 'localhost');
-    t.equal((proxy as any).db.port, 5432);
+    const {proxy}: {proxy: typeof store} = createConfigProxy(store);
+    t.equal(proxy.db.host, 'localhost');
+    t.equal(proxy.db.port, 5432);
 });
 
 test('createConfigProxy — reflects updated values after update()', async t => {
     const store = {db: {host: 'localhost'}};
-    const {proxy, update} = createConfigProxy(store);
+    const {proxy, update}: {proxy: typeof store; update: (newStore: typeof store) => void} =
+        createConfigProxy(store);
 
-    t.equal((proxy as any).db.host, 'localhost');
+    t.equal(proxy.db.host, 'localhost');
 
-    update({db: {host: '10.0.0.1'}} as any);
+    update({db: {host: '10.0.0.1'}});
 
-    t.equal((proxy as any).db.host, '10.0.0.1', 'proxy reflects updated value');
+    t.equal(proxy.db.host, '10.0.0.1', 'proxy reflects updated value');
 });
 
 test('createConfigProxy — proxy reference remains stable across updates', async t => {
     const store = {a: 1};
-    const {proxy, update} = createConfigProxy(store);
+    const {proxy, update}: {proxy: typeof store; update: (newStore: typeof store) => void} =
+        createConfigProxy(store);
 
     const ref1 = proxy;
-    update({a: 2} as any);
+    update({a: 2});
     const ref2 = proxy;
 
     t.equal(ref1, ref2, 'same proxy reference after update');
-    t.equal((ref1 as any).a, 2, 'old reference reflects new value');
+    t.equal(ref1.a, 2, 'old reference reflects new value');
 });
 
 test('createConfigProxy — has/ownKeys/enumeration work correctly', async t => {
@@ -135,8 +137,8 @@ test('createConfigProxy — has/ownKeys/enumeration work correctly', async t =>
 
 test('createConfigProxy — undefined properties return undefined', async t => {
     const store = {a: 1};
-    const {proxy} = createConfigProxy(store);
-    t.equal((proxy as any).nonExistent, undefined);
+    const {proxy}: {proxy: {a: number; nonExistent?: unknown}} = createConfigProxy(store);
+    t.equal(proxy.nonExistent, undefined);
 });
 
 // ---------------------------------------------------------------------------
@@ -162,7 +164,13 @@ test('createConfigProxy — undefined properties return undefined', async t => {
 
 test('partial destructuring — theme sub-object is a live proxy node that reflects current values after update', async t => {
     const initialStore = {theme: {name: 'light', mode: 'day'}};
-    const {proxy, update} = createConfigProxy(initialStore);
+    const {
+        proxy,
+        update,
+    }: {
+        proxy: {theme: {name: string; mode: string}};
+        update: (newStore: typeof initialStore) => void;
+    } = createConfigProxy(initialStore);
 
     // Simulate factory-time partial destructuring: extract the `theme` sub-object
     // (as would happen in `handler(({ config: { theme } }) => ...)`)
@@ -179,12 +187,16 @@ test('partial destructuring — theme sub-object is a live proxy node that refle
     //     root `current` cell, so it reflects the new values after update() ---
     t.equal(theme.name, 'dark', 'sub-proxy theme.name reflects update via path traversal');
     t.equal(theme.mode, 'night', 'sub-proxy theme.mode reflects update via path traversal');
-    t.equal((proxy as any).theme.name, 'dark', 'root proxy.theme.name also reflects update');
+    t.equal(proxy.theme.name, 'dark', 'root proxy.theme.name also reflects update');
 });
 
 test('full destructuring — scalar captured at factory time does NOT reflect later updates', async t => {
     const initialStore = {theme: {name: 'light'}};
-    const {proxy, update} = createConfigProxy(initialStore);
+    const {
+        proxy,
+        update,
+    }: {proxy: {theme: {name: string}}; update: (newStore: typeof initialStore) => void} =
+        createConfigProxy(initialStore);
 
     // Simulate the UNSAFE pattern: extract a leaf primitive at factory time
     // (as would happen in `handler(({ config: { theme: { name } } }) => ...)`)
@@ -201,7 +213,7 @@ test('full destructuring — scalar captured at factory time does NOT reflect la
     t.equal(capturedName, 'light', 'captured scalar is stale after config update');
 
     // Root proxy reflects the new value
-    t.equal((proxy as any).theme.name, 'dark', 'root proxy reflects updated value');
+    t.equal(proxy.theme.name, 'dark', 'root proxy reflects updated value');
 
     // This proves: NEVER destructure leaf primitives at handler factory time.
     t.not(
@@ -233,12 +245,19 @@ test('root proxy access — always reflects current values regardless of nesting
 // ---------------------------------------------------------------------------
 
 test('factory phase guard — throws on primitive read in default throw mode', async t => {
-    const {proxy, enterConfig, exitConfig} = createConfigProxy({host: 'localhost', port: 5432});
-    const p = proxy as any;
+    const {
+        proxy,
+        enterConfig,
+        exitConfig,
+    }: {
+        proxy: {host: string; port: number};
+        enterConfig: (mode?: 'throw' | 'collect') => void;
+        exitConfig: () => Error[];
+    } = createConfigProxy({host: 'localhost', port: 5432});
 
     enterConfig(); // default mode = 'throw'
     t.throws(
-        () => p.host,
+        () => proxy.host,
         /anti-pattern/,
         'reading a primitive during factory phase throws by default',
     );
@@ -247,7 +266,7 @@ test('factory phase guard — throws on primitive read in default throw mode', a
 
 test('factory phase guard — collects errors in collect mode without throwing', async t => {
     const {proxy, enterConfig, exitConfig} = createConfigProxy({host: 'localhost', port: 5432});
-    const p = proxy as any;
+    const p = proxy as {host: string; port: number};
 
     enterConfig('collect');
     t.doesNotThrow(() => p.host, 'no throw in collect mode');
@@ -261,7 +280,7 @@ test('factory phase guard — collects errors in collect mode without throwing',
 
 test('factory phase guard — sub-object read is NOT flagged (safe partial destructuring)', async t => {
     const {proxy, enterConfig, exitConfig} = createConfigProxy({theme: {name: 'light'}});
-    const p = proxy as any;
+    const p = proxy as {theme: {name: string}};
 
     enterConfig(); // throw mode
     t.doesNotThrow(
@@ -273,7 +292,7 @@ test('factory phase guard — sub-object read is NOT flagged (safe partial destr
 
 test('factory phase guard — undefined read is NOT flagged', async t => {
     const {proxy, enterConfig, exitConfig} = createConfigProxy({a: 1});
-    const p = proxy as any;
+    const p = proxy as {a: number; nonExistent?: unknown};
 
     enterConfig();
     t.doesNotThrow(
@@ -285,7 +304,7 @@ test('factory phase guard — undefined read is NOT flagged', async t => {
 
 test('factory phase guard — guard is inactive after exitConfigFactoryPhase', async t => {
     const {proxy, enterConfig, exitConfig} = createConfigProxy({host: 'localhost'});
-    const p = proxy as any;
+    const p = proxy as {host: string};
 
     enterConfig();
     exitConfig(); // exit immediately
@@ -295,11 +314,11 @@ test('factory phase guard — guard is inactive after exitConfigFactoryPhase', a
 
 test('factory phase guard — exitConfigFactoryPhase returns empty array in throw mode', async t => {
     const {proxy, enterConfig, exitConfig} = createConfigProxy({host: 'localhost'});
-    const p = proxy as any;
+    const p = proxy as {host: string};
 
     enterConfig(); // throw mode — errors are not collected
     try {
-        p.host; // would throw
+        void p.host; // would throw
     } catch (_) {
         // expected
     }

package/src/ConfigRuntime.ts

@@ -329,7 +329,7 @@ export default class ConfigRuntime implements IConfigRuntime {
     }
 
     /**
-     * Register a subscriber.  Returns an unsubscribe function for clean teardown.
+     * Register a subscriber.  Returns an unsubscribe function for clean tear-down.
      */
     public subscribe(fn: ConfigSubscriber): () => void {
         this.#subscribers.add(fn);

package/src/ErrorFactory.ts

@@ -32,7 +32,7 @@ export default class ErrorFactory extends Internal implements IErrorFactory {
         return this.#error.register(errors);
     }
 
-    public get(name: string): unknown {
+    public get(name: string) {
         return this.#error.get(name);
     }
 

package/src/Gateway.ts

@@ -47,7 +47,6 @@ const errorMap: IErrorMap = {
 };
 
 declare module 'fastify' {
-    // eslint-disable-next-line @typescript-eslint/naming-convention
     interface FastifyContextConfig {
         auth: unknown;
         mle?: unknown;
@@ -105,7 +104,7 @@ function operationParams(
                                     Object.assign(result, request.body);
                                 else if (parameter.schema?.properties)
                                     Object.entries(parameter.schema.properties).forEach(
-                                        ([name, value]) => {
+                                        ([name]) => {
                                             if (name in (request.body as Record<string, unknown>))
                                                 result[snakeToCamel(name)] = (
                                                     request.body as Record<string, unknown>
@@ -132,7 +131,7 @@ function operationParams(
         if ('additionalProperties' in bodySchema && bodySchema.additionalProperties)
             Object.assign(result, request.body);
         else if (bodySchema.properties)
-            Object.entries(bodySchema.properties).forEach(([name, value]) => {
+            Object.entries(bodySchema.properties).forEach(([name]) => {
                 if (name in (request.body as Record<string, unknown>))
                     result[snakeToCamel(name)] = (request.body as Record<string, unknown>)[name];
             });
@@ -351,7 +350,6 @@ export default class Gateway extends Internal implements IGateway {
                                 }),
                             }
                           : undefined),
-                    /* eslint-disable @typescript-eslint/naming-convention */
                     ...('response' in value && value.response
                         ? {response: {'2xx': value.response}}
                         : 'result' in value
@@ -391,7 +389,6 @@ export default class Gateway extends Internal implements IGateway {
                                           },
                             }
                           : undefined),
-                    /* eslint-enable @typescript-eslint/naming-convention */
                     security: [
                         value.auth === false
                             ? {}
@@ -473,7 +470,7 @@ export default class Gateway extends Internal implements IGateway {
                         } else if (id == null) {
                             const pub = this.#local.get(pubName);
                             if (!pub) return notfound();
-                            pub.method(params, meta).catch(error => {});
+                            pub.method(params, meta).catch(() => {});
                             return {
                                 jsonrpc: '2.0',
                                 result: true,
@@ -500,7 +497,9 @@ export default class Gateway extends Internal implements IGateway {
                             httpResponse?: unknown;
                             [key: string]: unknown;
                         };
-                        if (isExpectedError(typedError.type as string | undefined, resolvedExpect)) {
+                        if (
+                            isExpectedError(typedError.type as string | undefined, resolvedExpect)
+                        ) {
                             request.log.debug(
                                 {err: error, method: methodName},
                                 'gateway expected error',

package/src/GatewayClient.ts

@@ -58,9 +58,7 @@ export default class GatewayClientImpl extends Remote implements IGatewayClient
 
     public gateway(..._args: unknown[]): void {}
 
-    protected sender(
-        methodType: 'request' | 'publish',
-    ): (...params: unknown[]) => Promise<unknown> {
+    protected sender(): (...params: unknown[]) => Promise<unknown> {
         return async (...rest) => {
             const {stream, ...$meta} = rest.pop() as IMeta;
             const params = rest;

package/src/Local.ts

@@ -1,9 +1,13 @@
 import {type ILocal, Internal} from '@feasibleone/blong/types';
 
 export default class Local extends Internal implements ILocal {
-    #mapLocal: Record<string, {method: unknown}> = {};
+    #mapLocal: Record<string, {method: (...params: unknown[]) => Promise<unknown[]>}> = {};
 
-    private _localRegister(namespace: string, name: string, method: string): void {
+    private _localRegister(
+        namespace: string,
+        name: string,
+        method: (...params: unknown[]) => Promise<unknown[]>,
+    ): void {
         const local = this.#mapLocal[namespace + '.' + name];
         if (local) {
             local.method = method;
@@ -13,21 +17,31 @@ export default class Local extends Internal implements ILocal {
     }
 
     public register(
-        methods: object,
+        methods:
+            | Record<string, (...params: unknown[]) => Promise<unknown>>
+            | Array<(...params: unknown[]) => Promise<unknown>>,
         namespace: string,
-        reply: boolean,
-        pkg: {version: string},
+        // reply: boolean,
+        // pkg: {version: string},
     ): void {
         if (methods instanceof Array) {
             methods.forEach(fn => {
                 if (fn instanceof Function && fn.name) {
-                    this._localRegister(namespace, fn.name, fn);
+                    this._localRegister(
+                        namespace,
+                        fn.name,
+                        fn as (...params: unknown[]) => Promise<unknown[]>,
+                    );
                 }
             });
         } else {
             Object.keys(methods).forEach(key => {
                 if ((methods as Record<string, unknown>)[key] instanceof Function) {
-                    this._localRegister(namespace, key, (methods as Record<string, Function>)[key].bind(methods));
+                    this._localRegister(
+                        namespace,
+                        key,
+                        methods[key].bind(methods) as (...params: unknown[]) => Promise<unknown[]>,
+                    );
                 }
             });
         }

package/src/Log.ts

@@ -1,5 +1,5 @@
 import {Internal, type ILog, type ILogger} from '@feasibleone/blong/types';
-import {pino, type Logger, type LogFn, type LoggerOptions} from 'pino';
+import {pino, type LogFn, type Logger, type LoggerOptions} from 'pino';
 import {monotonicFactory} from 'ulidx';
 import type {CacacheTransportOptions} from './pino-cacache.js';
 
@@ -110,15 +110,15 @@ export default class Log extends Internal implements ILog {
         switch (level) {
             case 'trace':
                 result.trace = child.trace.bind(child);
-            case 'debug': // eslint-disable-line no-fallthrough
+            case 'debug':
                 result.debug = child.debug.bind(child);
-            case 'info': // eslint-disable-line no-fallthrough
+            case 'info':
                 result.info = child.info.bind(child);
-            case 'warn': // eslint-disable-line no-fallthrough
+            case 'warn':
                 result.warn = child.warn.bind(child);
-            case 'error': // eslint-disable-line no-fallthrough
+            case 'error':
                 result.error = child.error.bind(child);
-            case 'fatal': // eslint-disable-line no-fallthrough
+            case 'fatal':
                 result.fatal = child.fatal.bind(child);
         }
         return result as unknown as ILogger;

package/src/Port.ts

@@ -1,9 +1,9 @@
 import {Internal, type IAdapterFactory} from '@feasibleone/blong/types';
 // import {Port as UtPort} from 'ut-port';
 
-const UtPort = (config: unknown) =>
+const UtPort = () =>
     class Port extends Internal {
-        findHandler(name: string): unknown {
+        findHandler(_: string): unknown {
             return null;
         }
     };
@@ -13,9 +13,9 @@ export interface IPort {
 }
 
 export default class Port extends Internal {
-    public constructor(config: unknown) {
+    public constructor() {
         super();
-        const result = UtPort(config);
+        const result = UtPort();
         const findHandler = result.prototype.findHandler;
         result.prototype.findHandler = function (name: string) {
             return findHandler.call(this, name.replaceAll('.', '').toLowerCase());

package/src/Realm.ts

@@ -1,4 +1,4 @@
-import type {IAdapterFactory, IAdapterRegistry, ILog, IRegistry} from '@feasibleone/blong/types';
+import type {IAdapterRegistry, ILog, IRegistry} from '@feasibleone/blong/types';
 
 export interface IRealm {
     addModule: (name: string, mod: IRegistry) => void;

package/src/Remote.ts

@@ -142,7 +142,7 @@ export default class Remote extends Internal implements IRemote {
                 if ($meta && $meta.timeout && $meta.retry) {
                     return startRetry(
                         () => method(...params),
-                        $meta as {timeout?: number; retry?: number},
+                        $meta as unknown as {timeout?: number; retry?: number},
                     );
                 } else {
                     return method(...params);

package/src/ResolutionLocal.ts

@@ -21,8 +21,8 @@ export default class ResolutionLocal extends Internal implements IResolution {
 
     public async resolve(
         service: string,
-        invalidate: boolean,
-        namespace: string,
+        // invalidate: boolean,
+        // namespace: string,
     ): ReturnType<IResolution['resolve']> {
         return {
             // hostname: `${service}-service.${this.#config.domain}`,
@@ -33,7 +33,7 @@ export default class ResolutionLocal extends Internal implements IResolution {
         };
     }
 
-    public announce(service: string, port: number): void {}
+    public announce(): void {}
 
     public async start(): Promise<void> {}