@feasibleone/blong-gogo 1.18.1 → 1.19.0

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## [1.19.0](https://github.com/feasibleone/blong/compare/blong-gogo-v1.18.1...blong-gogo-v1.19.0) (2026-04-29)
+
+
+### Features
+
+* rename blong-int-sql → blong-int-adapter with full adapter integration test suite ([#135](https://github.com/feasibleone/blong/issues/135)) ([ee2b0f6](https://github.com/feasibleone/blong/commit/ee2b0f64b181f787a71c404e08fd62959a7f0e8e))
+
+
+### Bug Fixes
+
+* type errors ([2f105bd](https://github.com/feasibleone/blong/commit/2f105bd3546b30ad1505ccde63ba43f3ccd575a8))
+* type errors ([#133](https://github.com/feasibleone/blong/issues/133)) ([5b33e54](https://github.com/feasibleone/blong/commit/5b33e54b6b57eb561748a72f400a48f70af7f311))
+
 ## [1.18.1](https://github.com/feasibleone/blong/compare/blong-gogo-v1.18.0...blong-gogo-v1.18.1) (2026-04-26)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@feasibleone/blong-gogo",
-  "version": "1.18.1",
+  "version": "1.19.0",
   "repository": {
     "url": "git+https://github.com/feasibleone/blong.git"
   },
@@ -82,6 +82,7 @@
   "scripts": {
     "browser-check": "node scripts/browser-compat-check.mjs",
     "build": "true",
+    "ci-lint": "tsc --noEmit",
     "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/AdapterBase.ts

@@ -1,11 +1,13 @@
 import type {
+    Adapter,
     Config,
     Errors,
-    IAdapterFactory,
     IApi,
+    IContext,
     IErrorMap,
     IMeta,
     ITypedError,
+    PortHandlerBound,
 } from '@feasibleone/blong/types';
 import type net from 'node:net';
 import PQueue from 'p-queue';
@@ -70,14 +72,20 @@ const reserved: string[] = [
  * (`Object.setPrototypeOf(current, baseInstance)`), preserving the existing
  * hot-reload semantics.
  */
-export class AdapterBase<T = Record<string, unknown>, C = Record<string, unknown>> {
+type AdapterHandlerContext = {
+    importedMap?: Map<string, object>;
+    imported: object;
+    config: {namespace?: string | string[]};
+};
+
+export class AdapterBase<T, C extends IContext> implements AdapterHandlerContext {
     errors = _errors;
     exec: unknown = null;
-    imported: object = {};
+    imported: Record<string, PortHandlerBound> = {};
     config: Config<T, C> = {} as Config<T, C>;
     configBase: string;
     log: unknown = null;
-    importedMap?: Map<string, object>;
+    importedMap?: Map<string, Record<string, (...args: unknown[]) => unknown>>;
 
     // These are prefixed with _ rather than using # private class fields.
     // The adapter uses Object.setPrototypeOf(current, base) to set the base as
@@ -98,9 +106,9 @@ export class AdapterBase<T = Record<string, unknown>, C = Record<string, unknown
     _createLog: IApi['createLog'];
     _attachCheckpoint: IApi['attachCheckpoint'];
     _activationNames: string[];
-    _queue: PQueue;
+    _queue?: PQueue;
     _portLoop: any; // eslint-disable-line @typescript-eslint/no-explicit-any
-    _resolveConnected: (value: boolean) => void;
+    _resolveConnected?: (value: boolean) => void;
     _connected: Promise<boolean>;
 
     constructor(
@@ -128,15 +136,16 @@ export class AdapterBase<T = Record<string, unknown>, C = Record<string, unknown
         this._createLog = api.createLog;
         this._attachCheckpoint = api.attachCheckpoint;
         this._activationNames = activationNames;
-        let resolveConnected: (value: boolean) => void;
         this._connected = new Promise<boolean>(resolve => {
-            resolveConnected = resolve;
+            this._resolveConnected = resolve;
         });
-        this._resolveConnected = resolveConnected;
     }
 
     activeConfig(): object {
-        return ConfigRuntime.mergeActivationConfig(this, this._activationNames);
+        return ConfigRuntime.mergeActivationConfig(
+            this as {activation?: Record<string, unknown>},
+            this._activationNames,
+        );
     }
 
     async init(...configs: object[]): Promise<void> {
@@ -175,16 +184,18 @@ export class AdapterBase<T = Record<string, unknown>, C = Record<string, unknown
         }
     }
 
-    findValidation($meta: IMeta): unknown {
+    findValidation(): unknown {
         return null;
     }
 
     handles(name: string): boolean {
         if (reserved.includes(name)) return true;
         const id = this.config.id.replace(/\./g, '-');
-        return []
+        return ([] as (string | RegExp)[])
             .concat(this.config.namespace || this.config.imports || id)
-            .some(namespace => name.startsWith(namespace));
+            .some(namespace =>
+                typeof namespace === 'string' ? name.startsWith(namespace) : namespace.test(name),
+            );
     }
 
     methodPath(methodName: string): string {
@@ -195,9 +206,9 @@ export class AdapterBase<T = Record<string, unknown>, C = Record<string, unknown
         return methodName;
     }
 
-    getConversion($meta: IMeta, type: 'send' | 'receive'): {fn: unknown; name: string} {
+    getConversion($meta: IMeta | false, type: 'send' | 'receive'): {fn: unknown; name: string} {
         let fn;
-        let name: string;
+        let name: string = '';
         if ($meta) {
             if ($meta.method) {
                 const path = this._getPath($meta.method);
@@ -238,18 +249,15 @@ export class AdapterBase<T = Record<string, unknown>, C = Record<string, unknown
             $meta: {mtid: 'event', method: `adapter.${event}`},
             ...data,
         });
-        const eventHandlers = [];
+        const eventHandlers: Array<(...args: unknown[]) => unknown> = [];
         this.importedMap?.forEach(
             imp =>
-                Object.prototype.hasOwnProperty.call(imp, event) &&
-                eventHandlers.push(imp[event]),
+                Object.prototype.hasOwnProperty.call(imp, event) && eventHandlers.push(imp[event]),
         );
         let result: unknown = data;
         switch (mapper) {
             case 'asyncMap':
-                result = await Promise.all(
-                    eventHandlers.map(handler => handler.call(this, data)),
-                );
+                result = await Promise.all(eventHandlers.map(handler => handler.call(this, data)));
                 break;
             case 'reduce':
             default:
@@ -269,11 +277,11 @@ export class AdapterBase<T = Record<string, unknown>, C = Record<string, unknown
     }
 
     async request(...params: unknown[]): Promise<unknown> {
-        return this._queue.add(this._portLoop(params, true));
+        return this._queue!.add(this._portLoop(params, true));
     }
 
     async publish(...params: unknown[]): Promise<unknown> {
-        await this._queue.add(this._portLoop(params, false));
+        await this._queue!.add(this._portLoop(params, false));
         return [true, params[params.length - 1]];
     }
 
@@ -283,7 +291,7 @@ export class AdapterBase<T = Record<string, unknown>, C = Record<string, unknown
 
     forNamespaces<R>(reducer: (prev: R, current: unknown) => R, initial: R): R {
         const id = this.config.id.replace(/\./g, '-');
-        return []
+        return ([] as (string | RegExp)[])
             .concat(this.config.namespace || this.config.imports || id)
             .reduce(reducer.bind(this), initial);
     }
@@ -291,7 +299,13 @@ export class AdapterBase<T = Record<string, unknown>, C = Record<string, unknown
     async start(): Promise<unknown> {
         await this._api.attachHandlers(this, this.config.imports, true);
         const {req, pub} = this.forNamespaces(
-            (prev, next) => {
+            (
+                prev: {
+                    req: Record<string, (...args: unknown[]) => unknown>;
+                    pub: Record<string, (...args: unknown[]) => unknown>;
+                },
+                next,
+            ) => {
                 if (typeof next === 'string') {
                     prev.req[`${next}.request`] = this.request.bind(this);
                     prev.pub[`${next}.publish`] = this.publish.bind(this);
@@ -306,8 +320,11 @@ export class AdapterBase<T = Record<string, unknown>, C = Record<string, unknown
         return this.event('start', {configBase: this.configBase, config});
     }
 
-    async link(patterns: unknown, target: {imported?: object} = {}): Promise<object> {
-        await this._api.attachHandlers(target, patterns, false);
+    async link(
+        patterns: (string | RegExp)[] | string | RegExp,
+        target: AdapterHandlerContext = {} as unknown as AdapterHandlerContext,
+    ): Promise<object> {
+        await this._api.attachHandlers(target, patterns);
         return target.imported;
     }
 
@@ -323,14 +340,11 @@ export class AdapterBase<T = Record<string, unknown>, C = Record<string, unknown
         }
     }
 
-    connect(
-        what?: net.Socket | (() => void),
-        context?: any, // eslint-disable-line @typescript-eslint/no-explicit-any
-    ): void {
+    connect(what?: net.Socket | (() => void), context?: C): void {
         what ??= this.handle.bind(this);
         context ??= this.config.context;
         this._portLoop = loop(what, this as any, context); // eslint-disable-line @typescript-eslint/no-explicit-any
-        this._resolveConnected(true);
+        this._resolveConnected?.(true);
     }
 
     async connected(): Promise<boolean> {
@@ -349,26 +363,26 @@ export class AdapterBase<T = Record<string, unknown>, C = Record<string, unknown
  * placed at the end of the handler prototype chain.  This preserves the
  * constraint that realms/solutions never depend on blong-gogo.
  */
-export default async function adapter<T, C>(
+export default async function adapter<T, C extends IContext>(
     api: IApi,
     configBase: string,
     activationNames: string[] = [],
-): Promise<ReturnType<IAdapterFactory>> {
+): Promise<Adapter<T, C>> {
     const {adapter: adapterFactory, utError, handlers, remote, rpc, local, registry, type} = api;
     _errors ||= utError.register(errorMap);
 
     const base = new AdapterBase<T, C>(api, configBase, activationNames);
 
-    const result = handlers({utError, remote, type});
+    const result = handlers!({utError, remote, type});
     let current = result;
     while (current.extends) {
         const parent = await (typeof current.extends === 'string'
-            ? adapterFactory(current.extends)({utError, remote, rpc, local, registry})
+            ? adapterFactory(current.extends)!({utError, remote, rpc, local, registry})
             : current.extends({utError, remote, rpc, local, registry}));
         Object.setPrototypeOf(current, parent);
         current = parent;
     }
     Object.setPrototypeOf(current, base);
 
-    return result as ReturnType<IAdapterFactory>;
+    return result as Adapter<T, C>;
 }

package/src/ApiSchema.ts

@@ -1,4 +1,5 @@
 import type {
+    ApiSchema as ApiSchemaType,
     GatewaySchema,
     IApiSchema,
     ILog,
@@ -41,7 +42,10 @@ export default class ApiSchema extends Internal implements IApiSchema {
         this.merge(this.#config, config);
     }
 
-    public method(operation: {operationId?: string}): string {
+    public method(operation: {
+        operationId?: string;
+        'x-blong-method'?: string;
+    }): string | undefined {
         return operation?.['x-blong-method'] || operation.operationId;
     }
 
@@ -75,8 +79,10 @@ export default class ApiSchema extends Internal implements IApiSchema {
                         file.name.endsWith('.json'))
                 ) {
                     const [name] = this.#platform.basename(file.name).split('.');
-                    namespace[name] ||= [];
-                    namespace[name].push(this.#platform.join(dir, file.name));
+                    (namespace as Record<string, string[]>)[name] ||= [];
+                    (namespace as Record<string, string[]>)[name].push(
+                        this.#platform.join(dir, file.name),
+                    );
                 }
             }
         }
@@ -89,13 +95,18 @@ export default class ApiSchema extends Internal implements IApiSchema {
                 {},
             );
 
+        if (!namespace) return result;
+
         for (const [name, locations] of Object.entries(namespace)) {
             const bundle = await loadApi(locations, source, this.#platform);
-            const {namespace = name, destination} = bundle['x-blong'] ?? {};
-            this.#namespace[namespace] ||= {};
-            Object.entries(bundle.paths).forEach(([path, methods]: [string, PathItemObject]) => {
-                ['get', 'post', 'put', 'delete'].forEach(
-                    (httpMethod: 'get' | 'post' | 'put' | 'delete') => {
+            const blongMeta = (bundle as Record<string, unknown>)['x-blong'] as
+                | {namespace?: string; destination?: string}
+                | undefined;
+            const {namespace: nsName = name, destination} = blongMeta ?? {};
+            this.#namespace[nsName] ||= {};
+            Object.entries(bundle.paths ?? {}).forEach(
+                ([path, methods]: [string, PathItemObject]) => {
+                    (['get', 'post', 'put', 'delete'] as const).forEach(httpMethod => {
                         const operation = methods[httpMethod];
                         if (!operation) return;
                         const bodyParam = (
@@ -105,39 +116,46 @@ export default class ApiSchema extends Internal implements IApiSchema {
                         const definition: GatewaySchema = {
                             rpc: false,
                             auth: false,
-                            ...(bodyParam && {
-                                body: bodyParam,
-                            }),
+                            ...(bodyParam ? {body: bodyParam} : {}),
                             ...('requestBody' in operation && {
                                 body:
                                     'openapi' in bundle
-                                        ? 'content' in operation.requestBody &&
-                                          operation.requestBody.content?.['application/json']
+                                        ? 'content' in (operation.requestBody ?? {}) &&
+                                          (
+                                              operation.requestBody as {
+                                                  content?: Record<string, {schema?: unknown}>;
+                                              }
+                                          )?.content?.['application/json']
                                         : operation.requestBody,
                             }),
-                            basePath: `/rest/${namespace}`,
-                            response: (operation.responses?.['200'] as {content: unknown})
-                                ?.content?.['application/json']?.schema,
+                            basePath: `/rest/${nsName}`,
+                            response: (
+                                (
+                                    operation.responses?.['200'] as {
+                                        content?: Record<string, {schema?: unknown}>;
+                                    }
+                                )?.content?.['application/json'] as {schema?: unknown} | undefined
+                            )?.schema as ApiSchemaType | undefined,
                             description: operation.description,
                             summary: operation.summary,
                             destination,
                             method: httpMethod.toUpperCase() as Uppercase<typeof httpMethod>,
-                            subject: namespace,
+                            subject: nsName,
                             operation,
                             path: path.replaceAll('{', ':').replaceAll('}', ''),
                         };
-                        this.#loaded[`${namespace}${method}`.toLowerCase()] = definition;
-                        this.#namespace[namespace][`${namespace}.${method}`.toLowerCase()] =
-                            definition;
-                        result[`${namespace}.${method}`.toLowerCase()] = definition;
-                    },
-                );
-            });
+                        this.#loaded[`${nsName}${method}`.toLowerCase()] = definition;
+                        this.#namespace[nsName][`${nsName}.${method}`.toLowerCase()] = definition;
+                        result[`${nsName}.${method}`.toLowerCase()] = definition;
+                    });
+                },
+            );
         }
         const generate = [];
         for (const [prefix, record] of Object.entries(this.#generateDir)) {
             for (const [method, operation] of Object.entries(this.#loaded)) {
-                const filename = operation.subject + this.method(operation.operation) + '.ts';
+                const filename =
+                    (operation.subject ?? '') + this.method(operation.operation ?? {}) + '.ts';
                 if (method.startsWith(prefix) && !record.existing.has(filename.toLowerCase())) {
                     generate.push(this.#platform.join(record.dir, filename));
                 }
@@ -179,53 +197,61 @@ export default handler(
     }
 
     private _params(schema: GatewaySchema): string {
-        return schema?.operation?.parameters
-            ?.map((param: (typeof schema.operation.parameters)[0]) => {
-                if ('$ref' in param) return '';
-                if (!('in' in param)) return;
-                switch (param.in) {
-                    case 'header':
-                    case 'path':
-                    case 'query':
-                        return `    ${identifier(param.name)}${
-                            param.required ? ':' : '?:'
-                        } ${this._paramType(param)};${
-                            param.description
-                                ? ` // ${param.description.replaceAll(/[\r\n]/g, '')}`
-                                : ''
-                        }`;
-                    case 'body':
-                        if (param.schema?.type === 'object') {
-                            return Object.entries(param.schema.properties)
-                                .map(
-                                    ([name, property]: [string, {description?: string}]) =>
-                                        `    ${name}${param.required ? ':' : '?:'} ${this._type(
-                                            property,
-                                        )};${
-                                            property.description
-                                                ? ` // ${property.description.replaceAll(
-                                                      /[\r\n]/g,
-                                                      '',
-                                                  )}`
-                                                : ''
-                                        }`,
+        return (
+            schema?.operation?.parameters
+                ?.map((param: (typeof schema.operation.parameters)[0]) => {
+                    if ('$ref' in param) return '';
+                    if (!('in' in param)) return;
+                    switch (param.in) {
+                        case 'header':
+                        case 'path':
+                        case 'query':
+                            return `    ${identifier(param.name)}${
+                                param.required ? ':' : '?:'
+                            } ${this._paramType(param)};${
+                                param.description
+                                    ? ` // ${param.description.replaceAll(/[\r\n]/g, '')}`
+                                    : ''
+                            }`;
+                        case 'body':
+                            if (param.schema?.type === 'object') {
+                                return Object.entries(
+                                    (param.schema.properties as Record<
+                                        string,
+                                        {description?: string}
+                                    >) ?? {},
                                 )
-                                .join('\n');
-                        }
-                }
-            })
-            .filter(Boolean)
-            .join('\n');
+                                    .map(
+                                        ([name, property]: [string, {description?: string}]) =>
+                                            `    ${name}${param.required ? ':' : '?:'} ${this._type(
+                                                property,
+                                            )};${
+                                                property.description
+                                                    ? ` // ${property.description.replaceAll(
+                                                          /[\r\n]/g,
+                                                          '',
+                                                      )}`
+                                                    : ''
+                                            }`,
+                                    )
+                                    .join('\n');
+                            }
+                    }
+                })
+                .filter(Boolean)
+                .join('\n') ?? ''
+        );
     }
 
     private _response({operation}: GatewaySchema): string {
         if (!operation?.responses || !(200 in operation.responses)) return '';
-        if (!('schema' in operation.responses[200])) return '';
-        const schema = operation.responses?.[200]?.schema;
-        if (!schema || !('properties' in schema)) return '';
-        return Object.entries(schema.properties ?? {})
+        const resp200 = operation.responses[200] as Record<string, unknown> | undefined;
+        if (!resp200 || !('schema' in resp200)) return '';
+        const schema = resp200?.['schema'];
+        if (!schema || typeof schema !== 'object' || !('properties' in schema)) return '';
+        return Object.entries((schema as {properties: Record<string, unknown>}).properties ?? {})
             .map(([name, property]) => {
-                return `    ${name}: ${this._type(property)},`;
+                return `    ${name}: ${this._type(property as SchemaObject)},`;
             })
             .join('\n');
     }
@@ -253,11 +279,15 @@ export default handler(
             case 'boolean':
                 return 'boolean';
             case 'array':
-                return `${this._type(schema.items)}[]`;
+                return `${this._type(schema.items as SchemaObject)}[]`;
             case 'object':
-                return `{${Object.entries(schema.properties)
-                    .map(([name, property]) => `${name}: ${this._type(property)}`)
+                return `{${Object.entries(
+                    (schema as {properties?: Record<string, unknown>}).properties ?? {},
+                )
+                    .map(([name, property]) => `${name}: ${this._type(property as SchemaObject)}`)
                     .join('; ')}}`;
+            default:
+                return 'unknown';
         }
     }
 
@@ -290,5 +320,6 @@ export default handler(
         files.forEach(file =>
             record.existing.add(this.#platform.basename(file.name).toLowerCase()),
         );
+        return true;
     }
 }

package/src/BrowserLog.ts

@@ -61,16 +61,29 @@ interface ISimpleLogger {
     fatal(obj: unknown, msg?: string): void;
 }
 
-function write(rec: Record<string, unknown>, logByLevel: boolean): void {
+function write(
+    rec: {
+        time?: number;
+        level?: number | string;
+        name?: string;
+        childName?: string;
+        context?: string;
+        prefix?: string;
+        $meta?: {mtid?: string; method?: string};
+        msg?: string;
+        error?: unknown;
+    },
+    logByLevel: boolean,
+): void {
     const levelNum = rec.level as number;
     const levelKey = NAME_FROM_VALUE[levelNum] ?? 'info';
     const paddedLevel = levelKey.toUpperCase().padStart(5);
 
-    let consoleMethod: (...a: unknown[]) => void = console.log; // eslint-disable-line no-console
+    let consoleMethod: (...a: unknown[]) => void = console.log;
     if (logByLevel) {
         const mapped = levelNum <= 10 ? 'debug' : levelNum >= 60 ? 'error' : levelKey;
-        const c = console as unknown as Record<string, (...a: unknown[]) => void>; // eslint-disable-line no-console
-        consoleMethod = typeof c[mapped] === 'function' ? c[mapped] : console.log; // eslint-disable-line no-console
+        const c = console as unknown as Record<string, (...a: unknown[]) => void>;
+        consoleMethod = typeof c[mapped] === 'function' ? c[mapped] : console.log;
     }
 
     const levelCss = LEVEL_CSS[levelKey] ?? LEVEL_CSS.info;
@@ -110,7 +123,7 @@ function write(rec: Record<string, unknown>, logByLevel: boolean): void {
 
     consoleMethod(...args);
 
-    if (rec.error && (rec.error as {stack?: string}).stack) console.error(rec.error); // eslint-disable-line no-console
+    if (rec.error && (rec.error as {stack?: string}).stack) console.error(rec.error);
 }
 
 function createLogger(
@@ -183,19 +196,14 @@ export default class BrowserLog extends Internal implements ILog {
         switch (level) {
             case 'trace':
                 result.trace = child.trace.bind(child) as ILogger['trace'];
-            // eslint-disable-next-line no-fallthrough
             case 'debug':
                 result.debug = child.debug.bind(child) as ILogger['debug'];
-            // eslint-disable-next-line no-fallthrough
             case 'info':
                 result.info = child.info.bind(child) as ILogger['info'];
-            // eslint-disable-next-line no-fallthrough
             case 'warn':
                 result.warn = child.warn.bind(child) as ILogger['warn'];
-            // eslint-disable-next-line no-fallthrough
             case 'error':
                 result.error = child.error.bind(child) as ILogger['error'];
-            // eslint-disable-next-line no-fallthrough
             case 'fatal':
                 result.fatal = child.fatal.bind(child) as ILogger['fatal'];
         }

package/src/ConfigRuntime.ts

@@ -37,7 +37,7 @@ import merge from 'ut-function.merge';
  * are path-based views over the same root backing cell.
  *
  * IMPORTANT: the proxy is transparent — `typeof proxy`, `Array.isArray`, JSON
- * serialisation, and property enumeration all behave as they would on the
+ * serialization, and property enumeration all behave as they would on the
  * underlying plain object.  This means existing code that treats `config` as a
  * plain object continues to work without modification.
  */
@@ -130,7 +130,7 @@ export function createConfigProxy<T extends object>(
         }
 
         const pathProxy = new Proxy({} as T, {
-            get(_target, prop, _receiver) {
+            get(_target, prop) {
                 const container = getNode(path);
                 const val = container == null ? undefined : Reflect.get(container as object, prop);
                 if (val === undefined || val === null || typeof val !== 'object') {
@@ -142,7 +142,7 @@ export function createConfigProxy<T extends object>(
                     ) {
                         const error = new Error(
                             `Config hot-reload anti-pattern: '${prop}' is a primitive read from the config ` +
-                                `proxy during handler factory initialisation. The value will be captured once ` +
+                                `proxy during handler factory initialization. The value will be captured once ` +
                                 `and will NOT reflect future config reloads.\n` +
                                 `Fix: read the value inside the handler body instead:\n` +
                                 `  ✅  handler(({config}) => ({ fn: () => config.${prop} }))\n` +
@@ -165,7 +165,7 @@ export function createConfigProxy<T extends object>(
                 if (container == null) return false;
                 return Reflect.has(container as object, prop);
             },
-            ownKeys(_target) {
+            ownKeys() {
                 const container = getNode(path);
                 if (container == null) return [];
                 return Reflect.ownKeys(container as object);
@@ -175,7 +175,7 @@ export function createConfigProxy<T extends object>(
                 if (container == null) return undefined;
                 return Object.getOwnPropertyDescriptor(container as object, prop);
             },
-            getPrototypeOf(_target) {
+            getPrototypeOf() {
                 const container = getNode(path);
                 if (container == null) return Object.getPrototypeOf({});
                 return Object.getPrototypeOf(container as object);
@@ -316,7 +316,6 @@ export default class ConfigRuntime implements IConfigRuntime {
                     await subscriber(diff, next, prev);
                 } catch (error) {
                     // Subscriber errors must not break the reload pipeline
-                    // eslint-disable-next-line no-console
                     console.error('[ConfigRuntime] subscriber error:', error);
                 }
             }
@@ -338,7 +337,7 @@ export default class ConfigRuntime implements IConfigRuntime {
     }
 
     // -----------------------------------------------------------------------
-    // Centralised config merge methods
+    // Centralized config merge methods
     //
     // These replace the scattered merge operations in loadRealm(), layerProxy,
     // and adapter.activeConfig().  Each method encapsulates a specific merge
@@ -372,7 +371,7 @@ export default class ConfigRuntime implements IConfigRuntime {
      * @param activationNames - active environment names (e.g. `['dev']`)
      */
     static mergeActivationConfig(
-        target: object,
+        target: {activation?: Record<string, unknown>},
         activationNames: string[] = [],
     ): object {
         return merge([

package/src/ErrorFactory.ts

@@ -19,8 +19,8 @@ export default class ErrorFactory extends Internal implements IErrorFactory {
         this.merge(this.#config, config);
         this.#error = Errors({
             logFactory: {
-                createLog: (logLevel, bindings) => log?.logger(logLevel, bindings) || {},
-            },
+                createLog: (...params: Parameters<ILog['logger']>) => log?.logger(...params) || {},
+            } as unknown as Parameters<typeof Errors>[0]['logFactory'],
             logLevel: this.#config.logLevel,
             errorPrint: this.#config.errorPrint,
         });