@feasibleone/blong-gogo 1.17.0 → 1.18.0

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # Changelog
 
+## [1.18.0](https://github.com/feasibleone/blong/compare/blong-gogo-v1.17.1...blong-gogo-v1.18.0) (2026-04-26)
+
+
+### Features
+
+* add support for the browser platform ([f483e14](https://github.com/feasibleone/blong/commit/f483e149711acdeebcf9ee5afa3bf7ac7a6b669c))
+* implement wiring pipeline simplifications ([0a3dc01](https://github.com/feasibleone/blong/commit/0a3dc01e97c158d30491e8b76bef7d6bb4987529))
+* model handling ([168e77e](https://github.com/feasibleone/blong/commit/168e77ec3284bbcebf5d7d6bb07cc624d0d1a56e))
+* model mocks ([118a142](https://github.com/feasibleone/blong/commit/118a14254f87b8d1cf0b4d217939a9d49942f93e))
+* pino cacache log transport with ULID-linked terminal entries and VSCode click-to-inspect ([#126](https://github.com/feasibleone/blong/issues/126)) ([b3a91f5](https://github.com/feasibleone/blong/commit/b3a91f5d8e6fab1eaf02b81bbd20f2136e5ef267))
+
+
+### Bug Fixes
+
+* dependencies ([a21d8eb](https://github.com/feasibleone/blong/commit/a21d8ebe4ce9b476060dec8eeb9017a5eb7f07b5))
+* dependencies ([705b2f7](https://github.com/feasibleone/blong/commit/705b2f7a72ac2dc93aea0f586394dde71192c1b6))
+* eslint ([a3b9f2b](https://github.com/feasibleone/blong/commit/a3b9f2bed4f958abfb378d97d372b3e7a6cd5a21))
+* generic adapter ([e5ac7e7](https://github.com/feasibleone/blong/commit/e5ac7e7073aaf0e12258830585a38b055e2905ae))
+* optimize browser loading ([0aac985](https://github.com/feasibleone/blong/commit/0aac985a24520810dc05eb34d314ed7dec4f1962))
+* remove heft lint ([c4d0eaa](https://github.com/feasibleone/blong/commit/c4d0eaa81714c04e9f9adec01c6ae7fa068f1948))
+
+## [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)
 
 

package/bin/blong-dev.ts

@@ -1,7 +1,7 @@
-#!/usr/bin/env -S node --watch --inspect
+#!/usr/bin/env -S node --watch --conditions=development --inspect
 
 import minimist from 'minimist';
-import {autoRun} from '../src/loadServer.ts';
+import {autoRun} from '../src/runServer.ts';
 
 const argv: {_: string[]} = minimist(process.argv.slice(2));
 

package/bin/blong.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env -S node
 
 import minimist from 'minimist';
-import {autoRun} from '../src/loadServer.ts';
+import {autoRun} from '../src/runServer.ts';
 
 const argv: {_: string[]} = minimist(process.argv.slice(2));
 

package/package.json

@@ -1,16 +1,15 @@
 {
   "name": "@feasibleone/blong-gogo",
-  "version": "1.17.0",
+  "version": "1.18.0",
   "repository": {
     "url": "git+https://github.com/feasibleone/blong.git"
   },
   "type": "module",
   "exports": {
     ".": {
-      "browser": "./src/browser.ts",
-      "import": "./src/load.ts"
+      "browser": "./src/loadBrowser.ts",
+      "import": "./src/loadServer.ts"
     },
-    "./browser": "./src/adapter/browser.ts",
     "./ConfigRuntime.js": "./src/ConfigRuntime.ts"
   },
   "bin": {
@@ -20,7 +19,7 @@
   },
   "dependencies": {
     "@apidevtools/swagger-parser": "^12.1.0",
-    "@aws-sdk/client-s3": "^3.1003.0",
+    "@aws-sdk/client-s3": "^3.1037.0",
     "@fastify/basic-auth": "^6.2.0",
     "@fastify/bearer-auth": "^10.1.2",
     "@fastify/cookie": "^11.0.2",
@@ -38,13 +37,12 @@
     "@slack/webhook": "^7.0.7",
     "ajv-formats": "^3.0.1",
     "browser-process-hrtime": "^1.0.0",
+    "cacache": "^20.0.4",
     "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",
     "jose": "^6.2.1",
-    "undici": "^8.0.1",
     "knex": "^3.1.0",
     "ky": "^1.14.2",
     "lru-cache": "^11.2.4",
@@ -57,33 +55,33 @@
     "openapi-types": "^12.1.3",
     "p-queue": "^9.1.0",
     "pino": "^10.3.1",
+    "pino-abstract-transport": "^3.0.0",
     "pino-pretty": "^13.1.3",
     "reconnect-core": "^1.3.0",
+    "tinyglobby": "^0.2.16",
     "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",
     "ut-function.merge": "^1.5.6",
-    "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",
     "@rushstack/heft": "^1.2.6",
     "@rushstack/heft-lint-plugin": "^1.2.6",
     "@rushstack/heft-typescript-plugin": "^1.3.1",
+    "@types/cacache": "^20.0.1",
     "@types/node": "^24",
-    "eslint": "~9.39.2",
     "playwright": "^1.58.2",
-    "tap": "^21.6.2",
+    "tap": "^21.6.3",
     "typescript": "^5.9.3"
   },
   "scripts": {
-    "build": "true",
     "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/AdapterBase.ts

@@ -0,0 +1,374 @@
+import type {
+    Config,
+    Errors,
+    IAdapterFactory,
+    IApi,
+    IErrorMap,
+    IMeta,
+    ITypedError,
+} from '@feasibleone/blong/types';
+import type net from 'node:net';
+import PQueue from 'p-queue';
+import merge from 'ut-function.merge';
+
+import ConfigRuntime from './ConfigRuntime.ts';
+import loop from './loop.ts';
+
+const errorMap: IErrorMap = {
+    'adapter.configValidation': 'Adapter config validation:\r\n{message}',
+    'adapter.missingParameters': 'Missing parameters',
+    'adapter.missingMeta': 'Missing metadata',
+    'adapter.notConnected': 'No connection',
+    'adapter.disconnect': 'Adapter disconnected',
+    'adapter.disconnectBeforeResponse': 'Disconnect before response received',
+    'adapter.stream': 'Adapter stream error',
+    'adapter.timeout': 'Timeout',
+    'adapter.echoTimeout': 'Echo retries limit exceeded',
+    'adapter.unhandled': 'Unhandled adapter error',
+    'adapter.bufferOverflow': 'Message size of {size} exceeds the maximum of {max}',
+    'adapter.socketTimeout': 'Socket timeout',
+    'adapter.receiveTimeout': 'Receive timeout',
+    'adapter.dispatchFailure': 'Cannot dispatch message to bus',
+    'adapter.methodNotFound': 'Method {method} not found',
+    'adapter.queueNotFound': 'Queue not found',
+    'adapter.invalidPullStream': 'Invalid pull stream',
+    'adapter.paramsValidation': 'Method {method} parameters failed validation for: {fields}',
+    'adapter.resultValidation': 'Method {method} result failed validation for: {fields}',
+    'adapter.deadlock':
+        'Method {method} was recursively called, which may cause a deadlock!\nx-b3-traceid: {traceId}\nx-ut-stack: {sequence}',
+    'adapter.noMeta': '$meta not passed',
+    'adapter.noMetaForward': '$meta.forward not passed to method {method}',
+    'adapter.noTraceId': "$meta.forward['x-b3-traceid'] not passed to method {method}",
+};
+
+let _errors: Errors<typeof errorMap>;
+
+const reserved: string[] = [
+    'reducer',
+    'start',
+    'stop',
+    'ready',
+    'init',
+    'namespace',
+    'send',
+    'requestSend',
+    'responseSend',
+    'errorSend',
+    'receive',
+    'requestReceive',
+    'responseReceive',
+    'errorReceive',
+];
+
+/**
+ * AdapterBase — the runtime-provided base class for all adapters.
+ *
+ * This class replaces the plain-object literal that was previously defined
+ * inline in `adapter()`.  It is exposed through the runtime injection
+ * mechanism — realms and solutions never import it directly.  Custom
+ * adapters extend it via prototype-chain inheritance
+ * (`Object.setPrototypeOf(current, baseInstance)`), preserving the existing
+ * hot-reload semantics.
+ */
+export class AdapterBase<T = Record<string, unknown>, C = Record<string, unknown>> {
+    errors = _errors;
+    exec: unknown = null;
+    imported: object = {};
+    config: Config<T, C> = {} as Config<T, C>;
+    configBase: string;
+    log: unknown = null;
+    importedMap?: Map<string, object>;
+
+    // These are prefixed with _ rather than using # private class fields.
+    // The adapter uses Object.setPrototypeOf(current, base) to set the base as
+    // the prototype of the plain handler-result object.  When prototype methods
+    // are then called on `current`, `this` is `current` (not `base`), so
+    // JavaScript's brand-checking on # private fields throws.  Regular
+    // properties are found via normal prototype-chain lookup, which works.
+    _register: IApi['register'];
+    _subscribe: IApi['subscribe'];
+    _dispatch: IApi['dispatch'];
+    _methodId: IApi['methodId'];
+    _getPath: IApi['getPath'];
+    // _api is stored (not _attachHandlers directly) because Registry.ts sets
+    // api.attachHandlers = ... only *after* the port factory returns.  Storing
+    // the api object and reading api.attachHandlers lazily (at call time)
+    // ensures we always see the real function rather than the initial undefined.
+    _api: Pick<IApi, 'attachHandlers'>;
+    _createLog: IApi['createLog'];
+    _attachCheckpoint: IApi['attachCheckpoint'];
+    _activationNames: string[];
+    _queue: PQueue;
+    _portLoop: any; // eslint-disable-line @typescript-eslint/no-explicit-any
+    _resolveConnected: (value: boolean) => void;
+    _connected: Promise<boolean>;
+
+    constructor(
+        api: Pick<
+            IApi,
+            | 'register'
+            | 'subscribe'
+            | 'dispatch'
+            | 'methodId'
+            | 'getPath'
+            | 'attachHandlers'
+            | 'createLog'
+            | 'attachCheckpoint'
+        >,
+        configBase: string,
+        activationNames: string[] = [],
+    ) {
+        this.configBase = configBase;
+        this._register = api.register;
+        this._subscribe = api.subscribe;
+        this._dispatch = api.dispatch;
+        this._methodId = api.methodId;
+        this._getPath = api.getPath;
+        this._api = api;
+        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 = resolveConnected;
+    }
+
+    activeConfig(): object {
+        return ConfigRuntime.mergeActivationConfig(this, this._activationNames);
+    }
+
+    async init(...configs: object[]): Promise<void> {
+        this.config = merge(this.activeConfig(), ...configs) as Config<T, C>;
+        this.log = this._createLog?.(this.config.logLevel || 'info', {
+            ...this.config.log,
+            name: this.config.id,
+            context: this.config.type ?? 'dispatch',
+        });
+        const id = this.config.id.replace(/\./g, '-');
+        this._queue = new PQueue({concurrency: this.config.concurrency || 100});
+        this._register(
+            {
+                [`${id}.start`]: this.start.bind(this),
+                [`${id}.stop`]: this.stop.bind(this),
+            },
+            'ports',
+            this.config.id,
+            this.config.pkg,
+        );
+        this._subscribe(
+            {
+                [`${id}.drain`]: this.drain.bind(this),
+            },
+            'ports',
+            this.config.id,
+            this.config.pkg,
+        );
+    }
+
+    error(error: ITypedError, $meta: IMeta): void {
+        if ((this.log as {error?: (...args: unknown[]) => void})?.error) {
+            if (error.type && $meta?.expect?.includes?.(error.type)) return;
+            if ($meta) error.method = $meta.method;
+            (this.log as {error: (...args: unknown[]) => void}).error(error);
+        }
+    }
+
+    findValidation($meta: IMeta): unknown {
+        return null;
+    }
+
+    handles(name: string): boolean {
+        if (reserved.includes(name)) return true;
+        const id = this.config.id.replace(/\./g, '-');
+        return []
+            .concat(this.config.namespace || this.config.imports || id)
+            .some(namespace => name.startsWith(namespace));
+    }
+
+    methodPath(methodName: string): string {
+        const afterSlash = methodName.split('/', 2)[1];
+        if (afterSlash !== undefined) return afterSlash;
+        const strip = this.config?.stripNamespace;
+        if (strip) return methodName.split('.').slice(strip).join('.');
+        return methodName;
+    }
+
+    getConversion($meta: IMeta, type: 'send' | 'receive'): {fn: unknown; name: string} {
+        let fn;
+        let name: string;
+        if ($meta) {
+            if ($meta.method) {
+                const path = this._getPath($meta.method);
+                name = [path, $meta.mtid, type].join('.');
+                fn = this.findHandler(name);
+                if (!fn) {
+                    name = [this.methodPath(path), $meta.mtid, type].join('.');
+                    fn = this.findHandler(name);
+                }
+            }
+            if (!fn) {
+                name = [$meta.opcode, $meta.mtid, type].join('.');
+                fn = this.findHandler(name);
+            }
+            if (!fn) {
+                name = [$meta.mtid, type].join('.');
+                fn = this.findHandler(name);
+            }
+        }
+        if (!fn && (!$meta || $meta.mtid !== 'event')) {
+            name = type;
+            fn = this.findHandler(name);
+        }
+        return {fn, name};
+    }
+
+    async dispatch(...args: unknown[]): Promise<unknown> {
+        const result = this._dispatch(...args);
+        if (!result)
+            (this.log as {error?: (...args: unknown[]) => void})?.error?.(
+                this.errors['adapter.dispatchFailure']({args}),
+            );
+        return result;
+    }
+
+    async event(event: string, data?: object, mapper?: string): Promise<unknown> {
+        (this.log as {info?: (...args: unknown[]) => void})?.info?.({
+            $meta: {mtid: 'event', method: `adapter.${event}`},
+            ...data,
+        });
+        const eventHandlers = [];
+        this.importedMap?.forEach(
+            imp =>
+                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)),
+                );
+                break;
+            case 'reduce':
+            default:
+                for (const eventHandler of eventHandlers) {
+                    result = await eventHandler.call(this, result);
+                }
+                break;
+        }
+        return result;
+    }
+
+    drain(): void {}
+
+    findHandler(methodName: string): unknown {
+        methodName = this._methodId(methodName);
+        return this.imported[methodName];
+    }
+
+    async request(...params: unknown[]): Promise<unknown> {
+        return this._queue.add(this._portLoop(params, true));
+    }
+
+    async publish(...params: unknown[]): Promise<unknown> {
+        await this._queue.add(this._portLoop(params, false));
+        return [true, params[params.length - 1]];
+    }
+
+    async ready(): Promise<unknown> {
+        return this.event('ready');
+    }
+
+    forNamespaces<R>(reducer: (prev: R, current: unknown) => R, initial: R): R {
+        const id = this.config.id.replace(/\./g, '-');
+        return []
+            .concat(this.config.namespace || this.config.imports || id)
+            .reduce(reducer.bind(this), initial);
+    }
+
+    async start(): Promise<unknown> {
+        await this._api.attachHandlers(this, this.config.imports, true);
+        const {req, pub} = this.forNamespaces(
+            (prev, next) => {
+                if (typeof next === 'string') {
+                    prev.req[`${next}.request`] = this.request.bind(this);
+                    prev.pub[`${next}.publish`] = this.publish.bind(this);
+                }
+                return prev;
+            },
+            {req: {}, pub: {}},
+        );
+        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
+        return this.event('start', {configBase: this.configBase, config});
+    }
+
+    async link(patterns: unknown, target: {imported?: object} = {}): Promise<object> {
+        await this._api.attachHandlers(target, patterns, false);
+        return target.imported;
+    }
+
+    async handle(...params: unknown[]): Promise<unknown> {
+        const $meta = params && params.length > 1 && (params[params.length - 1] as IMeta);
+        if ($meta && typeof $meta === 'object') this._attachCheckpoint?.($meta);
+        const method = ($meta && $meta.method) || 'exec';
+        const handler = this.findHandler(method) || this.imported['exec'];
+        if (handler instanceof Function) {
+            return handler.apply(this, params);
+        } else {
+            throw this.errors['adapter.methodNotFound']({params: {method}});
+        }
+    }
+
+    connect(
+        what?: net.Socket | (() => void),
+        context?: any, // eslint-disable-line @typescript-eslint/no-explicit-any
+    ): 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);
+    }
+
+    async connected(): Promise<boolean> {
+        return this._connected;
+    }
+
+    async stop(): Promise<unknown> {
+        return this.event('stop');
+    }
+}
+
+/**
+ * Create an adapter instance from the API and handler definitions.
+ *
+ * The `AdapterBase` class is instantiated here (not imported by realms) and
+ * 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>(
+    api: IApi,
+    configBase: string,
+    activationNames: string[] = [],
+): Promise<ReturnType<IAdapterFactory>> {
+    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});
+    let current = result;
+    while (current.extends) {
+        const parent = await (typeof current.extends === 'string'
+            ? 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>;
+}

package/src/ApiSchema.ts

@@ -2,17 +2,15 @@ import type {
     GatewaySchema,
     IApiSchema,
     ILog,
+    IPlatformApi,
     PathItemObject,
     SchemaObject,
 } from '@feasibleone/blong/types';
 import {Internal} from '@feasibleone/blong/types';
-import {createReadStream, statSync, writeFileSync, type Dirent} from 'node:fs';
-import path, {basename, dirname, extname} from 'node:path';
+import {type Dirent} from 'node:fs';
 
-import {join} from 'path';
 import {identifier} from './lib.ts';
 import loadApi from './loadApi.ts';
-import scan from './scan.ts';
 
 interface IConfig {
     logLevel?: Parameters<ILog['logger']>[0];
@@ -24,6 +22,7 @@ export default class ApiSchema extends Internal implements IApiSchema {
         logLevel: 'debug',
         generate: true,
     };
+    #platform: IPlatformApi;
 
     #loaded: Record<string, GatewaySchema> = {};
     #namespace: Record<string, Record<string, GatewaySchema>> = {};
@@ -36,8 +35,9 @@ export default class ApiSchema extends Internal implements IApiSchema {
         }
     > = {};
 
-    public constructor(config: IConfig, {log}: {log: ILog}) {
+    public constructor(config: IConfig, {log, platform}: {log: ILog; platform: IPlatformApi}) {
         super({log});
+        this.#platform = platform;
         this.merge(this.#config, config);
     }
 
@@ -45,6 +45,13 @@ export default class ApiSchema extends Internal implements IApiSchema {
         return operation?.['x-blong-method'] || operation.operationId;
     }
 
+    public loadApi(
+        locations: string | string[] | object | object[] | {assets: object},
+        source: string = process.cwd(),
+    ): ReturnType<typeof loadApi> {
+        return loadApi(locations, source, this.#platform);
+    }
+
     public async schema(
         {
             namespace,
@@ -57,8 +64,8 @@ export default class ApiSchema extends Internal implements IApiSchema {
     ): Promise<Record<string, GatewaySchema>> {
         const result: Record<string, GatewaySchema> = {};
         if (url) {
-            const dir = dirname(url.startsWith('file://') ? url.slice(7) : url);
-            const files = await scan(dir);
+            const dir = this.#platform.dirname(url.startsWith('file://') ? url.slice(7) : url);
+            const files = await this.#platform.scan(dir);
             namespace = namespace || {};
             for (const file of files) {
                 if (
@@ -67,9 +74,9 @@ export default class ApiSchema extends Internal implements IApiSchema {
                         file.name.endsWith('.yml') ||
                         file.name.endsWith('.json'))
                 ) {
-                    const [name] = basename(file.name).split('.');
+                    const [name] = this.#platform.basename(file.name).split('.');
                     namespace[name] ||= [];
-                    namespace[name].push(join(dir, file.name));
+                    namespace[name].push(this.#platform.join(dir, file.name));
                 }
             }
         }
@@ -83,7 +90,7 @@ export default class ApiSchema extends Internal implements IApiSchema {
             );
 
         for (const [name, locations] of Object.entries(namespace)) {
-            const bundle = await loadApi(locations, source);
+            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]) => {
@@ -132,17 +139,17 @@ export default class ApiSchema extends Internal implements IApiSchema {
             for (const [method, operation] of Object.entries(this.#loaded)) {
                 const filename = operation.subject + this.method(operation.operation) + '.ts';
                 if (method.startsWith(prefix) && !record.existing.has(filename.toLowerCase())) {
-                    generate.push(path.join(record.dir, filename));
+                    generate.push(this.#platform.join(record.dir, filename));
                 }
             }
         }
         for (const filename of generate.concat(Array.from(this.#generateFile))) {
-            const method = basename(filename, extname(filename));
+            const method = this.#platform.basename(filename, this.#platform.extname(filename));
             const schema = this.#loaded[method.toLowerCase()];
             if (schema) {
                 // console.log(schema.operation.responses);
                 this.log?.warn?.(`Writing ${filename}`);
-                writeFileSync(
+                this.#platform.writeFileSync(
                     filename,
                     `import unchanged from '@feasibleone/blong';
 import {type IMeta, handler} from '@feasibleone/blong/types';
@@ -256,16 +263,8 @@ export default handler(
 
     public async generateFile(filename: string): Promise<boolean> {
         if (this.#config.generate === false) return false;
-        if (statSync(filename).size !== 0) return false;
-        let content = '';
-        await new Promise<void>((resolve, reject) => {
-            createReadStream(filename, {end: 50, encoding: 'utf-8'})
-                .on('data', chunk => {
-                    content += chunk;
-                })
-                .on('error', reject)
-                .on('close', resolve);
-        });
+        if (this.#platform.statSync(filename).size !== 0) return false;
+        let content = this.#platform.readFileSync(filename, {encoding: 'utf-8'}).toString('utf-8');
         if (content.includes('import unchanged from')) {
             this.#generateFile.add(filename);
             return false;
@@ -288,6 +287,8 @@ export default handler(
                 existing: new Set(),
             };
         }
-        files.forEach(file => record.existing.add(basename(file.name).toLowerCase()));
+        files.forEach(file =>
+            record.existing.add(this.#platform.basename(file.name).toLowerCase()),
+        );
     }
 }