@nimbus-sh/core 0.1.0

package/dist/substrate/lifo/node-compat/rimraf.js

@@ -0,0 +1,63 @@
+/**
+ * `rimraf` npm package shim for Lifo.
+ *
+ * Provides the rimraf(path, [opts], cb) callback API, rimraf.sync(path),
+ * and the modern rimraf v4+ promise-based API, all backed by the VFS
+ * fs shim's recursive rmdir.
+ */
+import { resolve } from './path.js';
+export function createRimraf(vfs, cwd) {
+    function removeSync(p) {
+        const abs = resolve(cwd, p);
+        if (!vfs.exists(abs))
+            return;
+        const stat = vfs.stat(abs);
+        if (stat.type === 'directory') {
+            vfs.rmdirRecursive(abs);
+        }
+        else {
+            vfs.unlink(abs);
+        }
+    }
+    function removeAsync(p) {
+        return new Promise((res, rej) => {
+            try {
+                removeSync(p);
+                res();
+            }
+            catch (e) {
+                rej(e);
+            }
+        });
+    }
+    // rimraf(path, [opts], cb) — classic callback API (rimraf v3)
+    function rimraf(p, optsOrCb, cb) {
+        const callback = typeof optsOrCb === 'function' ? optsOrCb : cb;
+        try {
+            removeSync(p);
+            callback?.(null);
+        }
+        catch (e) {
+            callback?.(e);
+        }
+    }
+    // rimraf.sync / rimrafSync
+    rimraf.sync = removeSync;
+    // Modern rimraf v4+ returns a promise
+    rimraf.rimraf = removeAsync;
+    rimraf.rimrafSync = removeSync;
+    // Native implementations (same thing in our shim)
+    rimraf.native = removeAsync;
+    rimraf.nativeSync = removeSync;
+    // Manual implementations (same thing in our shim)
+    rimraf.manual = removeAsync;
+    rimraf.manualSync = removeSync;
+    // Windows implementations (same thing in our shim)
+    rimraf.windows = removeAsync;
+    rimraf.windowsSync = removeSync;
+    // moveRemove implementations (same thing in our shim)
+    rimraf.moveRemove = removeAsync;
+    rimraf.moveRemoveSync = removeSync;
+    rimraf.default = rimraf;
+    return rimraf;
+}

package/dist/substrate/lifo/node-compat/stream.d.ts

@@ -0,0 +1,36 @@
+import { EventEmitter } from './events.js';
+export declare class Readable extends EventEmitter {
+    private _buffer;
+    protected _ended: boolean;
+    readable: boolean;
+    push(chunk: string | null): void;
+    read(): string | null;
+    pipe<T extends Writable>(dest: T): T;
+    destroy(): this;
+    setEncoding(_encoding: string): this;
+    resume(): this;
+    pause(): this;
+}
+export declare class Writable extends EventEmitter {
+    private _ended;
+    writable: boolean;
+    write(chunk: string, _encoding?: string, cb?: () => void): boolean;
+    end(chunk?: string): void;
+    destroy(): this;
+}
+export declare class Duplex extends Readable {
+    writable: boolean;
+    private _writableEnded;
+    write(chunk: string, _encoding?: string, cb?: () => void): boolean;
+    end(chunk?: string): void;
+}
+export declare class PassThrough extends Duplex {
+}
+declare const _default: {
+    Readable: typeof Readable;
+    Writable: typeof Writable;
+    Duplex: typeof Duplex;
+    PassThrough: typeof PassThrough;
+};
+export default _default;
+//# sourceMappingURL=stream.d.ts.map

package/dist/substrate/lifo/node-compat/stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../../../../src/substrate/lifo/node-compat/stream.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE3C,qBAAa,QAAS,SAAQ,YAAY;IACxC,OAAO,CAAC,OAAO,CAAgB;IAC/B,SAAS,CAAC,MAAM,UAAS;IACzB,QAAQ,UAAQ;IAEhB,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI;IAWhC,IAAI,IAAI,MAAM,GAAG,IAAI;IAKrB,IAAI,CAAC,CAAC,SAAS,QAAQ,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC;IAMpC,OAAO,IAAI,IAAI;IAOf,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAIpC,MAAM,IAAI,IAAI;IAId,KAAK,IAAI,IAAI;CAGd;AAED,qBAAa,QAAS,SAAQ,YAAY;IACxC,OAAO,CAAC,MAAM,CAAS;IACvB,QAAQ,UAAQ;IAEhB,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,IAAI,GAAG,OAAO;IAOlE,GAAG,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI;IAQzB,OAAO,IAAI,IAAI;CAMhB;AAED,qBAAa,MAAO,SAAQ,QAAQ;IAClC,QAAQ,UAAQ;IAChB,OAAO,CAAC,cAAc,CAAS;IAE/B,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,IAAI,GAAG,OAAO;IAOlE,GAAG,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI;CAM1B;AAED,qBAAa,WAAY,SAAQ,MAAM;CAAG;;;;;;;AAE1C,wBAA2D"}

package/dist/substrate/lifo/node-compat/stream.js

@@ -0,0 +1,90 @@
+import { EventEmitter } from './events.js';
+export class Readable extends EventEmitter {
+    _buffer = [];
+    _ended = false;
+    readable = true;
+    push(chunk) {
+        if (chunk === null) {
+            this._ended = true;
+            this.readable = false;
+            this.emit('end');
+        }
+        else {
+            this._buffer.push(chunk);
+            this.emit('data', chunk);
+        }
+    }
+    read() {
+        if (this._buffer.length > 0)
+            return this._buffer.shift();
+        return null;
+    }
+    pipe(dest) {
+        this.on('data', (chunk) => dest.write(chunk));
+        this.on('end', () => dest.end());
+        return dest;
+    }
+    destroy() {
+        this._ended = true;
+        this.readable = false;
+        this.emit('close');
+        return this;
+    }
+    setEncoding(_encoding) {
+        return this;
+    }
+    resume() {
+        return this;
+    }
+    pause() {
+        return this;
+    }
+}
+export class Writable extends EventEmitter {
+    _ended = false;
+    writable = true;
+    write(chunk, _encoding, cb) {
+        if (this._ended)
+            return false;
+        this.emit('data', chunk);
+        if (cb)
+            cb();
+        return true;
+    }
+    end(chunk) {
+        if (chunk)
+            this.write(chunk);
+        this._ended = true;
+        this.writable = false;
+        this.emit('finish');
+        this.emit('close');
+    }
+    destroy() {
+        this._ended = true;
+        this.writable = false;
+        this.emit('close');
+        return this;
+    }
+}
+export class Duplex extends Readable {
+    writable = true;
+    _writableEnded = false;
+    write(chunk, _encoding, cb) {
+        if (this._writableEnded)
+            return false;
+        this.emit('data', chunk);
+        if (cb)
+            cb();
+        return true;
+    }
+    end(chunk) {
+        if (chunk)
+            this.write(chunk);
+        this._writableEnded = true;
+        this.writable = false;
+        this.emit('finish');
+    }
+}
+export class PassThrough extends Duplex {
+}
+export default { Readable, Writable, Duplex, PassThrough };

package/dist/substrate/lifo/node-compat/string_decoder.d.ts

@@ -0,0 +1,11 @@
+export declare class StringDecoder {
+    private decoder;
+    constructor(encoding?: string);
+    write(buffer: Uint8Array): string;
+    end(buffer?: Uint8Array): string;
+}
+declare const _default: {
+    StringDecoder: typeof StringDecoder;
+};
+export default _default;
+//# sourceMappingURL=string_decoder.d.ts.map

package/dist/substrate/lifo/node-compat/string_decoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string_decoder.d.ts","sourceRoot":"","sources":["../../../../src/substrate/lifo/node-compat/string_decoder.ts"],"names":[],"mappings":"AAAA,qBAAa,aAAa;IACxB,OAAO,CAAC,OAAO,CAAc;gBAEjB,QAAQ,CAAC,EAAE,MAAM;IAY7B,KAAK,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM;IAIjC,GAAG,CAAC,MAAM,CAAC,EAAE,UAAU,GAAG,MAAM;CAIjC;;;;AAED,wBAAiC"}

package/dist/substrate/lifo/node-compat/string_decoder.js

@@ -0,0 +1,23 @@
+export class StringDecoder {
+    decoder;
+    constructor(encoding) {
+        const enc = (encoding || 'utf8').toLowerCase().replace('-', '');
+        const map = {
+            utf8: 'utf-8',
+            utf16le: 'utf-16le',
+            latin1: 'latin1',
+            ascii: 'ascii',
+            binary: 'latin1',
+        };
+        this.decoder = new TextDecoder(map[enc] || 'utf-8');
+    }
+    write(buffer) {
+        return this.decoder.decode(buffer, { stream: true });
+    }
+    end(buffer) {
+        if (buffer)
+            return this.decoder.decode(buffer);
+        return this.decoder.decode();
+    }
+}
+export default { StringDecoder };

package/dist/substrate/lifo/node-compat/timers.d.ts

@@ -0,0 +1,16 @@
+export declare const _setTimeout: typeof setTimeout;
+export declare const _setInterval: typeof setInterval;
+export declare const _clearTimeout: typeof clearTimeout;
+export declare const _clearInterval: typeof clearInterval;
+export declare function setImmediate(fn: (...args: unknown[]) => void, ...args: unknown[]): ReturnType<typeof setTimeout>;
+export declare function clearImmediate(id: ReturnType<typeof setTimeout>): void;
+declare const _default: {
+    setTimeout: typeof setTimeout;
+    setInterval: typeof setInterval;
+    clearTimeout: typeof clearTimeout;
+    clearInterval: typeof clearInterval;
+    setImmediate: typeof setImmediate;
+    clearImmediate: typeof clearImmediate;
+};
+export default _default;
+//# sourceMappingURL=timers.d.ts.map

package/dist/substrate/lifo/node-compat/timers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timers.d.ts","sourceRoot":"","sources":["../../../../src/substrate/lifo/node-compat/timers.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,WAAW,mBAAwB,CAAC;AACjD,eAAO,MAAM,YAAY,oBAAyB,CAAC;AACnD,eAAO,MAAM,aAAa,qBAA0B,CAAC;AACrD,eAAO,MAAM,cAAc,sBAA2B,CAAC;AAEvD,wBAAgB,YAAY,CAAC,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,UAAU,CAAC,OAAO,UAAU,CAAC,CAEhH;AAED,wBAAgB,cAAc,CAAC,EAAE,EAAE,UAAU,CAAC,OAAO,UAAU,CAAC,GAAG,IAAI,CAEtE;;;;;;;;;AAED,wBAOE"}

package/dist/substrate/lifo/node-compat/timers.js

@@ -0,0 +1,18 @@
+export const _setTimeout = globalThis.setTimeout;
+export const _setInterval = globalThis.setInterval;
+export const _clearTimeout = globalThis.clearTimeout;
+export const _clearInterval = globalThis.clearInterval;
+export function setImmediate(fn, ...args) {
+    return _setTimeout(() => fn(...args), 0);
+}
+export function clearImmediate(id) {
+    _clearTimeout(id);
+}
+export default {
+    setTimeout: _setTimeout,
+    setInterval: _setInterval,
+    clearTimeout: _clearTimeout,
+    clearInterval: _clearInterval,
+    setImmediate,
+    clearImmediate,
+};

package/dist/substrate/lifo/node-compat/tty.d.ts

@@ -0,0 +1,32 @@
+import { Readable, Writable } from './stream.js';
+/**
+ * Node.js `tty` module shim for Lifo.
+ *
+ * In the browser there is no real TTY, so ReadStream/WriteStream behave like
+ * plain streams with the TTY-specific properties stubbed to sensible defaults.
+ */
+export declare class ReadStream extends Readable {
+    readonly isTTY = true;
+    readonly isRaw = false;
+    setRawMode(_mode: boolean): this;
+}
+export declare class WriteStream extends Writable {
+    readonly isTTY = true;
+    columns: number;
+    rows: number;
+    clearLine(_dir: number, _cb?: () => void): boolean;
+    clearScreenDown(_cb?: () => void): boolean;
+    cursorTo(_x: number, _y?: number | (() => void), _cb?: () => void): boolean;
+    moveCursor(_dx: number, _dy: number, _cb?: () => void): boolean;
+    getColorDepth(): number;
+    hasColors(count?: number): boolean;
+    getWindowSize(): [number, number];
+}
+export declare function isatty(_fd: number): boolean;
+declare const _default: {
+    ReadStream: typeof ReadStream;
+    WriteStream: typeof WriteStream;
+    isatty: typeof isatty;
+};
+export default _default;
+//# sourceMappingURL=tty.d.ts.map

package/dist/substrate/lifo/node-compat/tty.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tty.d.ts","sourceRoot":"","sources":["../../../../src/substrate/lifo/node-compat/tty.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEjD;;;;;GAKG;AAEH,qBAAa,UAAW,SAAQ,QAAQ;IACtC,QAAQ,CAAC,KAAK,QAAQ;IACtB,QAAQ,CAAC,KAAK,SAAS;IAEvB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI;CAIjC;AAED,qBAAa,WAAY,SAAQ,QAAQ;IACvC,QAAQ,CAAC,KAAK,QAAQ;IACtB,OAAO,SAAM;IACb,IAAI,SAAM;IAEV,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,IAAI,GAAG,OAAO;IAOlD,eAAe,CAAC,GAAG,CAAC,EAAE,MAAM,IAAI,GAAG,OAAO;IAM1C,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,CAAC,MAAM,IAAI,CAAC,EAAE,GAAG,CAAC,EAAE,MAAM,IAAI,GAAG,OAAO;IAgB3E,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,IAAI,GAAG,OAAO;IAW/D,aAAa,IAAI,MAAM;IAIvB,SAAS,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO;IAKlC,aAAa,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC;CAGlC;AAED,wBAAgB,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAE3C;;;;;;AAED,wBAAmD"}

package/dist/substrate/lifo/node-compat/tty.js

@@ -0,0 +1,76 @@
+import { Readable, Writable } from './stream.js';
+/**
+ * Node.js `tty` module shim for Lifo.
+ *
+ * In the browser there is no real TTY, so ReadStream/WriteStream behave like
+ * plain streams with the TTY-specific properties stubbed to sensible defaults.
+ */
+export class ReadStream extends Readable {
+    isTTY = true;
+    isRaw = false;
+    setRawMode(_mode) {
+        // no-op – raw mode is not applicable in the browser
+        return this;
+    }
+}
+export class WriteStream extends Writable {
+    isTTY = true;
+    columns = 80;
+    rows = 24;
+    clearLine(_dir, _cb) {
+        const mode = _dir < 0 ? 1 : _dir > 0 ? 0 : 2;
+        this.write(`\x1b[${mode}K`);
+        _cb?.();
+        return true;
+    }
+    clearScreenDown(_cb) {
+        this.write('\x1b[0J');
+        _cb?.();
+        return true;
+    }
+    cursorTo(_x, _y, _cb) {
+        if (typeof _y === 'function') {
+            _cb = _y;
+            _y = undefined;
+        }
+        const col = Math.max(0, Math.floor(Number(_x) || 0)) + 1;
+        if (_y === undefined) {
+            this.write(`\x1b[${col}G`);
+        }
+        else {
+            const row = Math.max(0, Math.floor(Number(_y) || 0)) + 1;
+            this.write(`\x1b[${row};${col}H`);
+        }
+        _cb?.();
+        return true;
+    }
+    moveCursor(_dx, _dy, _cb) {
+        const x = Math.trunc(Number(_dx) || 0);
+        const y = Math.trunc(Number(_dy) || 0);
+        if (x < 0)
+            this.write(`\x1b[${-x}D`);
+        else if (x > 0)
+            this.write(`\x1b[${x}C`);
+        if (y < 0)
+            this.write(`\x1b[${-y}A`);
+        else if (y > 0)
+            this.write(`\x1b[${y}B`);
+        _cb?.();
+        return true;
+    }
+    getColorDepth() {
+        return 8; // 256 colours – reasonable default for a virtual terminal
+    }
+    hasColors(count) {
+        if (count === undefined)
+            return true;
+        return count <= 256;
+    }
+    getWindowSize() {
+        return [this.columns, this.rows];
+    }
+}
+export function isatty(_fd) {
+    return false;
+}
+export default { ReadStream, WriteStream, isatty };

package/dist/substrate/lifo/node-compat/url.d.ts

@@ -0,0 +1,37 @@
+declare const NativeURL: typeof URL;
+declare const NativeURLSearchParams: typeof URLSearchParams;
+export { NativeURL as URL, NativeURLSearchParams as URLSearchParams };
+export declare function parse(urlString: string): {
+    protocol: string | null;
+    hostname: string | null;
+    port: string | null;
+    pathname: string;
+    search: string | null;
+    hash: string | null;
+    host: string | null;
+    href: string;
+    path: string;
+    query: string | null;
+};
+export declare function format(urlObj: {
+    protocol?: string;
+    hostname?: string;
+    port?: string | number;
+    pathname?: string;
+    search?: string;
+    hash?: string;
+}): string;
+export declare function resolve(from: string, to: string): string;
+export declare function fileURLToPath(url: string | URL): string;
+export declare function pathToFileURL(path: string): URL;
+declare const _default: {
+    URL: typeof URL;
+    URLSearchParams: typeof URLSearchParams;
+    parse: typeof parse;
+    format: typeof format;
+    resolve: typeof resolve;
+    fileURLToPath: typeof fileURLToPath;
+    pathToFileURL: typeof pathToFileURL;
+};
+export default _default;
+//# sourceMappingURL=url.d.ts.map

package/dist/substrate/lifo/node-compat/url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"url.d.ts","sourceRoot":"","sources":["../../../../src/substrate/lifo/node-compat/url.ts"],"names":[],"mappings":"AAAA,QAAA,MAAM,SAAS,YAAM,CAAC;AACtB,QAAA,MAAM,qBAAqB,wBAAkB,CAAC;AAE9C,OAAO,EAAE,SAAS,IAAI,GAAG,EAAE,qBAAqB,IAAI,eAAe,EAAE,CAAC;AAEtE,wBAAgB,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG;IACxC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB,CA6BA;AAED,wBAAgB,MAAM,CAAC,MAAM,EAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAS1J;AAED,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAExD;AAED,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,GAAG,MAAM,CAOvD;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG,CAE/C;;;;;;;;;;AAED,wBAA8F"}

package/dist/substrate/lifo/node-compat/url.js

@@ -0,0 +1,65 @@
+const NativeURL = URL;
+const NativeURLSearchParams = URLSearchParams;
+export { NativeURL as URL, NativeURLSearchParams as URLSearchParams };
+export function parse(urlString) {
+    try {
+        const u = new URL(urlString);
+        return {
+            protocol: u.protocol,
+            hostname: u.hostname,
+            port: u.port || null,
+            pathname: u.pathname,
+            search: u.search || null,
+            hash: u.hash || null,
+            host: u.host,
+            href: u.href,
+            path: u.pathname + (u.search || ''),
+            query: u.search ? u.search.slice(1) : null,
+        };
+    }
+    catch {
+        return {
+            protocol: null,
+            hostname: null,
+            port: null,
+            pathname: urlString,
+            search: null,
+            hash: null,
+            host: null,
+            href: urlString,
+            path: urlString,
+            query: null,
+        };
+    }
+}
+export function format(urlObj) {
+    let result = '';
+    if (urlObj.protocol)
+        result += urlObj.protocol + '//';
+    if (urlObj.hostname)
+        result += urlObj.hostname;
+    if (urlObj.port)
+        result += ':' + urlObj.port;
+    if (urlObj.pathname)
+        result += urlObj.pathname;
+    if (urlObj.search)
+        result += urlObj.search;
+    if (urlObj.hash)
+        result += urlObj.hash;
+    return result;
+}
+export function resolve(from, to) {
+    return new URL(to, from).href;
+}
+export function fileURLToPath(url) {
+    const urlStr = typeof url === 'string' ? url : url.href;
+    if (!urlStr.startsWith('file://')) {
+        throw new TypeError('The URL must be of scheme file');
+    }
+    // Remove file:// prefix and decode percent-encoded characters
+    return decodeURIComponent(urlStr.slice(7));
+}
+export function pathToFileURL(path) {
+    return new URL('file://' + encodeURI(path));
+}
+export default { URL, URLSearchParams, parse, format, resolve, fileURLToPath, pathToFileURL };

package/dist/substrate/lifo/node-compat/util.d.ts

@@ -0,0 +1,42 @@
+export declare function format(fmt: string, ...args: unknown[]): string;
+export declare function inspect(obj: unknown, opts?: {
+    depth?: number;
+    colors?: boolean;
+}): string;
+export declare function promisify<T>(fn: (...args: [...unknown[], (err: unknown, result: T) => void]) => void): (...args: unknown[]) => Promise<T>;
+export declare function inherits(ctor: {
+    prototype: object;
+    super_?: unknown;
+}, superCtor: {
+    prototype: object;
+} | null | undefined): void;
+export declare function deprecate<T extends (...args: unknown[]) => unknown>(fn: T, msg: string): T;
+export declare function types(): {
+    isDate: (v: unknown) => v is Date;
+    isRegExp: (v: unknown) => v is RegExp;
+    isArray: (arg: any) => arg is any[];
+};
+/** Strip ANSI/VT control sequences from a string (ESC[...m, etc.) */
+export declare function stripVTControlCharacters(str: string): string;
+declare const RuntimeTextDecoder: new (label?: string, options?: {
+    fatal?: boolean;
+    ignoreBOM?: boolean;
+}) => TextDecoder;
+declare const RuntimeTextEncoder: new () => TextEncoder;
+export { RuntimeTextDecoder as TextDecoder, RuntimeTextEncoder as TextEncoder, };
+declare const _default: {
+    format: typeof format;
+    inspect: typeof inspect;
+    promisify: typeof promisify;
+    inherits: typeof inherits;
+    deprecate: typeof deprecate;
+    types: typeof types;
+    stripVTControlCharacters: typeof stripVTControlCharacters;
+    TextDecoder: new (label?: string, options?: {
+        fatal?: boolean;
+        ignoreBOM?: boolean;
+    }) => TextDecoder;
+    TextEncoder: new () => TextEncoder;
+};
+export default _default;
+//# sourceMappingURL=util.d.ts.map

package/dist/substrate/lifo/node-compat/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../../../src/substrate/lifo/node-compat/util.ts"],"names":[],"mappings":"AAAA,wBAAgB,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,MAAM,CA2B9D;AAED,wBAAgB,OAAO,CAAC,GAAG,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,MAAM,CAGzF;AAqCD,wBAAgB,SAAS,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,GAAG,OAAO,EAAE,EAAE,CAAC,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,KAAK,IAAI,CAAC,KAAK,IAAI,GAAG,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,CAAC,CAAC,CAOzI;AAED,wBAAgB,QAAQ,CAAC,IAAI,EAAE;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,OAAO,CAAA;CAAE,EAAE,SAAS,EAAE;IAAE,SAAS,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,GAAG,SAAS,GAAG,IAAI,CASjI;AAED,wBAAgB,SAAS,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,EAAE,EAAE,EAAE,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,CAAC,CAS1F;AAED,wBAAgB,KAAK;gBAEL,OAAO;kBACL,OAAO;;EAGxB;AAED,qEAAqE;AACrE,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAG5D;AAED,QAAA,MAAM,kBAAkB;SAjGhB,CAAC;aACL,CAAH;iBAgGqC,CAAC;AACvC,QAAA,MAAM,kBAAkB,uBAAc,CAAC;AAEvC,OAAO,EACN,kBAAkB,IAAI,WAAW,EACjC,kBAAkB,IAAI,WAAW,GACjC,CAAC;;;;;;;;;;aAvGM,CAAC;iBACL,CAAH;;;;AAwGD,wBAUE"}

package/dist/substrate/lifo/node-compat/util.js

@@ -0,0 +1,132 @@
+export function format(fmt, ...args) {
+    if (typeof fmt !== 'string') {
+        return [fmt, ...args].map((a) => inspect(a)).join(' ');
+    }
+    let i = 0;
+    let result = fmt.replace(/%([sdjoO%])/g, (match, type) => {
+        if (type === '%')
+            return '%';
+        if (i >= args.length)
+            return match;
+        const arg = args[i++];
+        switch (type) {
+            case 's': return String(arg);
+            case 'd': return String(Number(arg));
+            case 'j':
+                try {
+                    return JSON.stringify(arg);
+                }
+                catch {
+                    return '[Circular]';
+                }
+            case 'o':
+            case 'O': return inspect(arg);
+            default: return match;
+        }
+    });
+    // Append remaining args
+    while (i < args.length) {
+        result += ' ' + inspect(args[i++]);
+    }
+    return result;
+}
+export function inspect(obj, opts) {
+    const depth = opts?.depth ?? 2;
+    return formatValue(obj, depth);
+}
+function formatValue(value, depth) {
+    if (value === null)
+        return 'null';
+    if (value === undefined)
+        return 'undefined';
+    const type = typeof value;
+    if (type === 'string')
+        return `'${value}'`;
+    if (type === 'number' || type === 'boolean' || type === 'bigint')
+        return String(value);
+    if (type === 'symbol')
+        return value.toString();
+    if (type === 'function')
+        return `[Function: ${value.name || 'anonymous'}]`;
+    if (value instanceof Date)
+        return value.toISOString();
+    if (value instanceof RegExp)
+        return value.toString();
+    if (value instanceof Error)
+        return `${value.name}: ${value.message}`;
+    if (Array.isArray(value)) {
+        if (depth < 0)
+            return '[Array]';
+        const items = value.map((v) => formatValue(v, depth - 1));
+        return `[ ${items.join(', ')} ]`;
+    }
+    if (value instanceof Uint8Array) {
+        return `<Buffer ${Array.from(value.slice(0, 50)).map((b) => b.toString(16).padStart(2, '0')).join(' ')}${value.length > 50 ? ' ...' : ''}>`;
+    }
+    if (typeof value === 'object') {
+        if (depth < 0)
+            return '[Object]';
+        const entries = Object.entries(value);
+        if (entries.length === 0)
+            return '{}';
+        const pairs = entries.map(([k, v]) => `${k}: ${formatValue(v, depth - 1)}`);
+        return `{ ${pairs.join(', ')} }`;
+    }
+    return String(value);
+}
+export function promisify(fn) {
+    return (...args) => new Promise((resolve, reject) => {
+        fn(...args, (err, result) => {
+            if (err)
+                reject(err);
+            else
+                resolve(result);
+        });
+    });
+}
+export function inherits(ctor, superCtor) {
+    if (superCtor === undefined || superCtor === null) {
+        throw new TypeError('The super constructor to "inherits" must not be null or undefined');
+    }
+    if (typeof superCtor.prototype === 'undefined') {
+        throw new TypeError('The super constructor to "inherits" must have a prototype');
+    }
+    ctor.super_ = superCtor;
+    Object.setPrototypeOf(ctor.prototype, superCtor.prototype);
+}
+export function deprecate(fn, msg) {
+    let warned = false;
+    return ((...args) => {
+        if (!warned) {
+            console.warn(`DeprecationWarning: ${msg}`);
+            warned = true;
+        }
+        return fn(...args);
+    });
+}
+export function types() {
+    return {
+        isDate: (v) => v instanceof Date,
+        isRegExp: (v) => v instanceof RegExp,
+        isArray: Array.isArray,
+    };
+}
+/** Strip ANSI/VT control sequences from a string (ESC[...m, etc.) */
+export function stripVTControlCharacters(str) {
+    // eslint-disable-next-line no-control-regex
+    return str.replace(/\x1B\[[0-9;]*[a-zA-Z]|\x1B\].*?(?:\x07|\x1B\\)/g, '');
+}
+const RuntimeTextDecoder = TextDecoder;
+const RuntimeTextEncoder = TextEncoder;
+export { RuntimeTextDecoder as TextDecoder, RuntimeTextEncoder as TextEncoder, };
+export default {
+    format,
+    inspect,
+    promisify,
+    inherits,
+    deprecate,
+    types,
+    stripVTControlCharacters,
+    TextDecoder: RuntimeTextDecoder,
+    TextEncoder: RuntimeTextEncoder,
+};