@serveryyswys/node.operit 0.1.2 → 0.1.3

package/dist/index.d.ts

@@ -1,8 +1,75 @@
+import eventsModule = require('./events');
+import querystringModule = require('./querystring');
+import stringDecoderModule = require('./string_decoder');
+import streamModule = require('./stream');
 import bufferModule = require('./buffer');
 import osModule = require('./os');
 declare const api: {
     version: string;
     path: import("./lib/path-types").PathModule;
+    'path/posix': import("./lib/path-types").PathModule;
+    'path/win32': import("./lib/path-types").PathModule;
+    events: typeof eventsModule;
+    querystring: typeof querystringModule;
+    string_decoder: typeof stringDecoderModule;
+    util: {
+        format: (template?: unknown, ...rest: unknown[]) => string;
+        formatWithOptions: (options: import("./lib/util-types").InspectOptions, template?: unknown, ...rest: unknown[]) => string;
+        inspect: (value: unknown, options?: import("./lib/util-types").InspectOptions | boolean | number) => string;
+        inherits: (constructor: Function, superConstructor: Function) => void;
+        promisify: (original: Function) => Function;
+        callbackify: (original: Function) => Function;
+        deprecate: (fn: Function, message: string) => Function;
+        debuglog: (section: string) => Function & {
+            enabled: boolean;
+        };
+        getSystemErrorName: (errno: number) => string;
+        stripVTControlCharacters: (value: string) => string;
+        isDeepStrictEqual: (left: unknown, right: unknown) => boolean;
+        types: {
+            isDate: (value: unknown) => boolean;
+            isRegExp: (value: unknown) => boolean;
+            isArray: (value: unknown) => boolean;
+            isTypedArray: (value: unknown) => boolean;
+            isUint8Array: (value: unknown) => boolean;
+            isArrayBuffer: (value: unknown) => boolean;
+            isPromise: (value: unknown) => boolean;
+            isNativeError: (value: unknown) => boolean;
+            isMap: (value: unknown) => boolean;
+            isSet: (value: unknown) => boolean;
+            isBigInt64Array: (value: unknown) => boolean;
+            isAsyncFunction: (value: unknown) => boolean;
+            isGeneratorFunction: (value: unknown) => boolean;
+        };
+        TextEncoder: {
+            new (): {
+                readonly encoding: "utf-8";
+                encode(input?: string): Uint8Array;
+                encodeInto(source: string, destination: Uint8Array): {
+                    read: number;
+                    written: number;
+                };
+            };
+        };
+        TextDecoder: {
+            new (label?: string, options?: {
+                fatal?: boolean;
+                ignoreBOM?: boolean;
+            }): {
+                readonly encoding: string;
+                readonly fatal: boolean;
+                readonly ignoreBOM: boolean;
+                decode(input?: Uint8Array): string;
+            };
+        };
+    };
+    assert: ((value: unknown, message?: unknown) => void) & Record<string, unknown>;
+    'assert/strict': any;
+    stream: typeof streamModule;
+    'stream/promises': {
+        pipeline: (...streams: unknown[]) => Promise<void>;
+        finished: (stream: unknown) => Promise<void>;
+    };
     fs: {
         readFileSync: (target: unknown, options?: unknown) => string | bufferModule.Buffer;
         writeFileSync: (target: unknown, data: unknown, options?: unknown) => void;
@@ -299,6 +366,158 @@ declare const api: {
         };
         env: typeof import("./lib/fs-env");
     };
+    'fs/promises': {
+        open: (path: unknown, flags?: unknown, mode?: unknown) => Promise<{
+            readonly fd: number;
+            closed: boolean;
+            ensureOpen(): void;
+            read(buffer: Uint8Array, offset?: number, length?: number, position?: number | null): Promise<{
+                bytesRead: number;
+                buffer: Uint8Array;
+            }>;
+            write(data: unknown, ...rest: unknown[]): Promise<{
+                bytesWritten: number;
+                buffer: unknown;
+            }>;
+            readFile(options?: unknown): Promise<string | Uint8Array>;
+            writeFile(data: unknown, options?: unknown): Promise<void>;
+            appendFile(data: unknown, options?: unknown): Promise<void>;
+            stat(): Promise<unknown>;
+            truncate(length?: number): Promise<void>;
+            sync(): Promise<void>;
+            datasync(): Promise<void>;
+            close(): Promise<void>;
+        }>;
+        readFile: (target: unknown, options?: unknown) => Promise<string | bufferModule.Buffer>;
+        writeFile: (target: unknown, data: unknown, options?: unknown) => Promise<void>;
+        appendFile: (target: unknown, data: unknown, options?: unknown) => Promise<void>;
+        stat: (target: unknown, options?: unknown) => Promise<{
+            readonly sizeValue: number;
+            readonly modeValue: number;
+            readonly atimeMsValue: number;
+            readonly mtimeMsValue: number;
+            readonly ctimeMsValue: number;
+            readonly birthtimeMsValue: number;
+            readonly fileLike: boolean;
+            readonly directoryLike: boolean;
+            readonly linkLike: boolean;
+            get size(): number;
+            get mode(): number;
+            get atimeMs(): number;
+            get mtimeMs(): number;
+            get ctimeMs(): number;
+            get birthtimeMs(): number;
+            get atime(): Date;
+            get mtime(): Date;
+            get ctime(): Date;
+            get birthtime(): Date;
+            isFile(): boolean;
+            isDirectory(): boolean;
+            isSymbolicLink(): boolean;
+            isBlockDevice(): boolean;
+            isCharacterDevice(): boolean;
+            isFIFO(): boolean;
+            isSocket(): boolean;
+        } | undefined>;
+        lstat: (target: unknown, options?: unknown) => Promise<{
+            readonly sizeValue: number;
+            readonly modeValue: number;
+            readonly atimeMsValue: number;
+            readonly mtimeMsValue: number;
+            readonly ctimeMsValue: number;
+            readonly birthtimeMsValue: number;
+            readonly fileLike: boolean;
+            readonly directoryLike: boolean;
+            readonly linkLike: boolean;
+            get size(): number;
+            get mode(): number;
+            get atimeMs(): number;
+            get mtimeMs(): number;
+            get ctimeMs(): number;
+            get birthtimeMs(): number;
+            get atime(): Date;
+            get mtime(): Date;
+            get ctime(): Date;
+            get birthtime(): Date;
+            isFile(): boolean;
+            isDirectory(): boolean;
+            isSymbolicLink(): boolean;
+            isBlockDevice(): boolean;
+            isCharacterDevice(): boolean;
+            isFIFO(): boolean;
+            isSocket(): boolean;
+        } | undefined>;
+        readdir: (target: unknown, options?: unknown) => Promise<string[] | {
+            readonly name: string;
+            readonly kind: number;
+            isFile(): boolean;
+            isDirectory(): boolean;
+            isSymbolicLink(): boolean;
+            isBlockDevice(): boolean;
+            isCharacterDevice(): boolean;
+            isFIFO(): boolean;
+            isSocket(): boolean;
+        }[]>;
+        mkdir: (target: unknown, options?: unknown) => Promise<string | undefined>;
+        rm: (target: unknown, options?: unknown) => Promise<void>;
+        unlink: (target: unknown) => Promise<void>;
+        rmdir: (target: unknown, options?: unknown) => Promise<void>;
+        rename: (from: unknown, to: unknown) => Promise<void>;
+        copyFile: (from: unknown, to: unknown) => Promise<void>;
+        realpath: (target: unknown) => Promise<string>;
+        readlink: (target: unknown) => Promise<string>;
+        symlink: (target: unknown, linkPath: unknown) => Promise<void>;
+        chmod: (target: unknown, mode: unknown) => Promise<void>;
+        truncate: (target: unknown, length?: unknown) => Promise<void>;
+        utimes: (target: unknown, atime: unknown, mtime: unknown) => Promise<void>;
+        access: (target: unknown) => Promise<void>;
+        mkdtemp: (prefix: unknown) => Promise<string>;
+        constants: {
+            F_OK: number;
+            R_OK: number;
+            W_OK: number;
+            X_OK: number;
+            COPYFILE_EXCL: number;
+            COPYFILE_FICLONE: number;
+            COPYFILE_FICLONE_FORCE: number;
+            UV_FS_COPYFILE_EXCL: number;
+            UV_FS_COPYFILE_FICLONE: number;
+            UV_FS_COPYFILE_FICLONE_FORCE: number;
+            O_RDONLY: number;
+            O_WRONLY: number;
+            O_RDWR: number;
+            O_CREAT: number;
+            O_EXCL: number;
+            O_TRUNC: number;
+            O_APPEND: number;
+            UV_FS_O_FILEMAP: number;
+            UV_FS_SYMLINK_DIR: number;
+            UV_FS_SYMLINK_JUNCTION: number;
+            UV_DIRENT_UNKNOWN: number;
+            UV_DIRENT_FILE: number;
+            UV_DIRENT_DIR: number;
+            UV_DIRENT_LINK: number;
+            UV_DIRENT_FIFO: number;
+            UV_DIRENT_SOCKET: number;
+            UV_DIRENT_CHAR: number;
+            UV_DIRENT_BLOCK: number;
+            S_IFMT: number;
+            S_IFREG: number;
+            S_IFDIR: number;
+            S_IFCHR: number;
+            S_IFIFO: number;
+            S_IFLNK: number;
+            S_IRUSR: number;
+            S_IWUSR: number;
+            S_IXUSR: number;
+            S_IRGRP: number;
+            S_IWGRP: number;
+            S_IXGRP: number;
+            S_IROTH: number;
+            S_IWOTH: number;
+            S_IXOTH: number;
+        };
+    };
     buffer: typeof bufferModule;
     os: typeof osModule;
     process: {
@@ -1366,11 +1585,11 @@ declare const api: {
             };
             defaultMaxListeners: number;
             errorMonitor: symbol;
-            EventEmitter: typeof import("./events");
-            listenerCount(emitter: import("./events"), name: string | symbol): number;
-            getEventListeners(emitter: import("./events"), name: string | symbol): ((...args: unknown[]) => void)[];
-            once(emitter: import("./events"), name: string | symbol): Promise<unknown[]>;
-            on(emitter: import("./events"), name: string | symbol): void;
+            EventEmitter: typeof eventsModule;
+            listenerCount(emitter: eventsModule, name: string | symbol): number;
+            getEventListeners(emitter: eventsModule, name: string | symbol): ((...args: unknown[]) => void)[];
+            once(emitter: eventsModule, name: string | symbol): Promise<unknown[]>;
+            on(emitter: eventsModule, name: string | symbol): void;
         };
     };
     url: {
@@ -1887,11 +2106,11 @@ declare const api: {
             };
             defaultMaxListeners: number;
             errorMonitor: symbol;
-            EventEmitter: typeof import("./events");
-            listenerCount(emitter: import("./events"), name: string | symbol): number;
-            getEventListeners(emitter: import("./events"), name: string | symbol): ((...args: unknown[]) => void)[];
-            once(emitter: import("./events"), name: string | symbol): Promise<unknown[]>;
-            on(emitter: import("./events"), name: string | symbol): void;
+            EventEmitter: typeof eventsModule;
+            listenerCount(emitter: eventsModule, name: string | symbol): number;
+            getEventListeners(emitter: eventsModule, name: string | symbol): ((...args: unknown[]) => void)[];
+            once(emitter: eventsModule, name: string | symbol): Promise<unknown[]>;
+            on(emitter: eventsModule, name: string | symbol): void;
         };
         IncomingMessage: {
             new (response: import("./lib/http-driver").HttpHostResponse): {
@@ -1946,13 +2165,13 @@ declare const api: {
                     }>;
                 };
             };
-            once(emitter: import("./events"), name: string | symbol): Promise<unknown[]>;
-            on(emitter: import("./events"), name: string | symbol): void;
+            once(emitter: eventsModule, name: string | symbol): Promise<unknown[]>;
+            on(emitter: eventsModule, name: string | symbol): void;
             defaultMaxListeners: number;
             errorMonitor: symbol;
-            EventEmitter: typeof import("./events");
-            listenerCount(emitter: import("./events"), name: string | symbol): number;
-            getEventListeners(emitter: import("./events"), name: string | symbol): ((...args: unknown[]) => void)[];
+            EventEmitter: typeof eventsModule;
+            listenerCount(emitter: eventsModule, name: string | symbol): number;
+            getEventListeners(emitter: eventsModule, name: string | symbol): ((...args: unknown[]) => void)[];
             from(iterable: unknown): {
                 addEntry(name: string | symbol, listener: (...args: unknown[]) => void, once: boolean, prepend?: boolean): /*elided*/ any;
                 emit(name: string | symbol, ...args: unknown[]): boolean;
@@ -2204,11 +2423,11 @@ declare const api: {
             };
             defaultMaxListeners: number;
             errorMonitor: symbol;
-            EventEmitter: typeof import("./events");
-            listenerCount(emitter: import("./events"), name: string | symbol): number;
-            getEventListeners(emitter: import("./events"), name: string | symbol): ((...args: unknown[]) => void)[];
-            once(emitter: import("./events"), name: string | symbol): Promise<unknown[]>;
-            on(emitter: import("./events"), name: string | symbol): void;
+            EventEmitter: typeof eventsModule;
+            listenerCount(emitter: eventsModule, name: string | symbol): number;
+            getEventListeners(emitter: eventsModule, name: string | symbol): ((...args: unknown[]) => void)[];
+            once(emitter: eventsModule, name: string | symbol): Promise<unknown[]>;
+            on(emitter: eventsModule, name: string | symbol): void;
         };
         IncomingMessage: {
             new (response: import("./lib/http-driver").HttpHostResponse): {
@@ -2263,13 +2482,13 @@ declare const api: {
                     }>;
                 };
             };
-            once(emitter: import("./events"), name: string | symbol): Promise<unknown[]>;
-            on(emitter: import("./events"), name: string | symbol): void;
+            once(emitter: eventsModule, name: string | symbol): Promise<unknown[]>;
+            on(emitter: eventsModule, name: string | symbol): void;
             defaultMaxListeners: number;
             errorMonitor: symbol;
-            EventEmitter: typeof import("./events");
-            listenerCount(emitter: import("./events"), name: string | symbol): number;
-            getEventListeners(emitter: import("./events"), name: string | symbol): ((...args: unknown[]) => void)[];
+            EventEmitter: typeof eventsModule;
+            listenerCount(emitter: eventsModule, name: string | symbol): number;
+            getEventListeners(emitter: eventsModule, name: string | symbol): ((...args: unknown[]) => void)[];
             from(iterable: unknown): {
                 addEntry(name: string | symbol, listener: (...args: unknown[]) => void, once: boolean, prepend?: boolean): any;
                 emit(name: string | symbol, ...args: unknown[]): boolean;
@@ -2418,5 +2637,185 @@ declare const api: {
         getDefaultResultOrder: () => string;
         setDefaultResultOrder: (order: unknown) => void;
     };
+    console: {
+        Console: {
+            new (stdout?: unknown, stderr?: unknown): {
+                readonly stdout: import("./lib/console-types").WriteStreamLike | null;
+                readonly stderr: import("./lib/console-types").WriteStreamLike | null;
+                readonly counts: Map<string, number>;
+                readonly timers: Map<string, number>;
+                indent: string;
+                emit(target: import("./lib/console-types").WriteStreamLike | null, channel: 'log' | 'info' | 'warn' | 'error', text: string): void;
+                line(...args: unknown[]): string;
+                log(...args: unknown[]): void;
+                info(...args: unknown[]): void;
+                debug(...args: unknown[]): void;
+                warn(...args: unknown[]): void;
+                error(...args: unknown[]): void;
+                assert(value: unknown, ...args: unknown[]): void;
+                dir(value: unknown, options?: unknown): void;
+                count(label?: string): void;
+                countReset(label?: string): void;
+                time(label?: string): void;
+                timeEnd(label?: string): void;
+                timeLog(label?: string, ...args: unknown[]): void;
+                trace(...args: unknown[]): void;
+                table(data: unknown, columns?: readonly string[]): void;
+                group(...args: unknown[]): void;
+                groupCollapsed(...args: unknown[]): void;
+                groupEnd(): void;
+                clear(): void;
+                profile(): void;
+                profileEnd(): void;
+                timeStamp(): void;
+            };
+        };
+        log: (...args: unknown[]) => void;
+        info: (...args: unknown[]) => void;
+        debug: (...args: unknown[]) => void;
+        warn: (...args: unknown[]) => void;
+        error: (...args: unknown[]) => void;
+        assert: (value: unknown, ...args: unknown[]) => void;
+        dir: (value: unknown, options?: unknown) => void;
+        count: (label?: string) => void;
+        countReset: (label?: string) => void;
+        time: (label?: string) => void;
+        timeEnd: (label?: string) => void;
+        timeLog: (label?: string, ...args: unknown[]) => void;
+        trace: (...args: unknown[]) => void;
+        table: (data: unknown, columns?: readonly string[]) => void;
+        group: (...args: unknown[]) => void;
+        groupCollapsed: (...args: unknown[]) => void;
+        groupEnd: () => void;
+        clear: () => void;
+        profile: () => void;
+        profileEnd: () => void;
+        timeStamp: () => void;
+    };
+    'util/types': {
+        isDate: (value: unknown) => boolean;
+        isRegExp: (value: unknown) => boolean;
+        isArray: (value: unknown) => boolean;
+        isTypedArray: (value: unknown) => boolean;
+        isUint8Array: (value: unknown) => boolean;
+        isArrayBuffer: (value: unknown) => boolean;
+        isPromise: (value: unknown) => boolean;
+        isNativeError: (value: unknown) => boolean;
+        isMap: (value: unknown) => boolean;
+        isSet: (value: unknown) => boolean;
+        isBigInt64Array: (value: unknown) => boolean;
+        isAsyncFunction: (value: unknown) => boolean;
+        isGeneratorFunction: (value: unknown) => boolean;
+    };
+    sys: {
+        format: (template?: unknown, ...rest: unknown[]) => string;
+        formatWithOptions: (options: import("./lib/util-types").InspectOptions, template?: unknown, ...rest: unknown[]) => string;
+        inspect: (value: unknown, options?: import("./lib/util-types").InspectOptions | boolean | number) => string;
+        inherits: (constructor: Function, superConstructor: Function) => void;
+        promisify: (original: Function) => Function;
+        callbackify: (original: Function) => Function;
+        deprecate: (fn: Function, message: string) => Function;
+        debuglog: (section: string) => Function & {
+            enabled: boolean;
+        };
+        getSystemErrorName: (errno: number) => string;
+        stripVTControlCharacters: (value: string) => string;
+        isDeepStrictEqual: (left: unknown, right: unknown) => boolean;
+        types: {
+            isDate: (value: unknown) => boolean;
+            isRegExp: (value: unknown) => boolean;
+            isArray: (value: unknown) => boolean;
+            isTypedArray: (value: unknown) => boolean;
+            isUint8Array: (value: unknown) => boolean;
+            isArrayBuffer: (value: unknown) => boolean;
+            isPromise: (value: unknown) => boolean;
+            isNativeError: (value: unknown) => boolean;
+            isMap: (value: unknown) => boolean;
+            isSet: (value: unknown) => boolean;
+            isBigInt64Array: (value: unknown) => boolean;
+            isAsyncFunction: (value: unknown) => boolean;
+            isGeneratorFunction: (value: unknown) => boolean;
+        };
+        TextEncoder: {
+            new (): {
+                readonly encoding: "utf-8";
+                encode(input?: string): Uint8Array;
+                encodeInto(source: string, destination: Uint8Array): {
+                    read: number;
+                    written: number;
+                };
+            };
+        };
+        TextDecoder: {
+            new (label?: string, options?: {
+                fatal?: boolean;
+                ignoreBOM?: boolean;
+            }): {
+                readonly encoding: string;
+                readonly fatal: boolean;
+                readonly ignoreBOM: boolean;
+                decode(input?: Uint8Array): string;
+            };
+        };
+    };
+    punycode: {
+        version: string;
+        ucs2: {
+            decode: (value: string) => number[];
+            encode: (codePoints: readonly number[]) => string;
+        };
+        decode: typeof import("./lib/punycode").decode;
+        encode: typeof import("./lib/punycode").encode;
+        toASCII: typeof import("./lib/punycode").toASCII;
+        toUnicode: typeof import("./lib/punycode").toUnicode;
+    };
+    diagnostics_channel: {
+        channel: (name: string) => {
+            readonly name: string;
+            subscribers: import("./lib/diagnostics-channel-types").Subscriber[];
+            get hasSubscribers(): boolean;
+            subscribe(onMessage: import("./lib/diagnostics-channel-types").Subscriber): void;
+            unsubscribe(onMessage: import("./lib/diagnostics-channel-types").Subscriber): void;
+            publish(message: unknown): void;
+            bindStore(_store: import("./lib/diagnostics-channel-types").ChannelStore, _transform?: unknown): void;
+            unbindStore(_store: import("./lib/diagnostics-channel-types").ChannelStore): void;
+            runStores(_context: unknown, _fn: Function, _thisArg?: unknown, ..._args: unknown[]): unknown;
+        };
+        hasSubscribers: (name: string) => boolean;
+        subscribe: (name: string, onMessage: import("./lib/diagnostics-channel-types").Subscriber) => void;
+        unsubscribe: (name: string, onMessage: import("./lib/diagnostics-channel-types").Subscriber) => void;
+        Channel: {
+            new (name: string): {
+                readonly name: string;
+                subscribers: import("./lib/diagnostics-channel-types").Subscriber[];
+                get hasSubscribers(): boolean;
+                subscribe(onMessage: import("./lib/diagnostics-channel-types").Subscriber): void;
+                unsubscribe(onMessage: import("./lib/diagnostics-channel-types").Subscriber): void;
+                publish(message: unknown): void;
+                bindStore(_store: import("./lib/diagnostics-channel-types").ChannelStore, _transform?: unknown): void;
+                unbindStore(_store: import("./lib/diagnostics-channel-types").ChannelStore): void;
+                runStores(_context: unknown, _fn: Function, _thisArg?: unknown, ..._args: unknown[]): unknown;
+            };
+        };
+    };
+    'stream/consumers': {
+        buffer: (stream: import("./lib/stream-consumers-types").ReadableLike) => Promise<bufferModule.Buffer>;
+        text: (stream: import("./lib/stream-consumers-types").ReadableLike) => Promise<string>;
+        json: (stream: import("./lib/stream-consumers-types").ReadableLike) => Promise<unknown>;
+        arrayBuffer: (stream: import("./lib/stream-consumers-types").ReadableLike) => Promise<ArrayBuffer>;
+        blob: (_stream: import("./lib/stream-consumers-types").ReadableLike) => Promise<never>;
+    };
+    v8: {
+        getHeapStatistics: () => import("./lib/v8-types").HeapStatistics;
+        getHeapSpaceStatistics: () => import("./lib/v8-types").HeapSpaceStatistics[];
+        getHeapCodeStatistics: () => import("./lib/v8-types").HeapCodeStatistics;
+        serialize: () => never;
+        deserialize: () => never;
+        setFlagsFromString: () => never;
+        cachedDataVersionTag: () => never;
+        writeHeapSnapshot: () => never;
+        takeCoverage: () => never;
+        stopCoverage: () => never;
+    };
 };
 export = api;

package/dist/index.js

@@ -13,8 +13,19 @@
  * Stream 类本身），无法在 .d.ts 里被"命名"，加进来会让本文件的声明生成失败。
  * 需要它请直接引子路径。
  */
+const pathPosixModule = require("./path/posix");
+const pathWin32Module = require("./path/win32");
+const eventsModule = require("./events");
+const querystringModule = require("./querystring");
+const stringDecoderModule = require("./string_decoder");
+const utilModule = require("./util");
+const assertModule = require("./assert");
+const assertStrictModule = require("./assert/strict");
+const streamModule = require("./stream");
+const streamPromisesModule = require("./stream/promises");
 const pathModule = require("./path");
 const fsModule = require("./fs");
+const fsPromisesModule = require("./fs/promises");
 const bufferModule = require("./buffer");
 const osModule = require("./os");
 const processModule = require("./process");
@@ -32,10 +43,28 @@ const httpModule = require("./http");
 const httpsModule = require("./https");
 const dnsModule = require("./dns");
 const dnsPromisesModule = require("./dns/promises");
+const consoleModule = require("./console");
+const utilTypesModule = require("./util/types");
+const sysModule = require("./sys");
+const punycodeModule = require("./punycode");
+const diagnosticsChannelModule = require("./diagnostics_channel");
+const streamConsumersModule = require("./stream/consumers");
+const v8Module = require("./v8");
 const api = {
-    version: '0.1.0',
+    version: '0.1.3',
     path: pathModule,
+    'path/posix': pathPosixModule,
+    'path/win32': pathWin32Module,
+    events: eventsModule,
+    querystring: querystringModule,
+    string_decoder: stringDecoderModule,
+    util: utilModule,
+    assert: assertModule,
+    'assert/strict': assertStrictModule,
+    stream: streamModule,
+    'stream/promises': streamPromisesModule,
     fs: fsModule,
+    'fs/promises': fsPromisesModule,
     buffer: bufferModule,
     os: osModule,
     process: processModule,
@@ -52,6 +81,13 @@ const api = {
     http: httpModule,
     https: httpsModule,
     dns: dnsModule,
-    'dns/promises': dnsPromisesModule
+    'dns/promises': dnsPromisesModule,
+    console: consoleModule,
+    'util/types': utilTypesModule,
+    sys: sysModule,
+    punycode: punycodeModule,
+    diagnostics_channel: diagnosticsChannelModule,
+    'stream/consumers': streamConsumersModule,
+    v8: v8Module
 };
 module.exports = api;

package/dist/lib/bridge.js

@@ -44,7 +44,9 @@ function getBackend() {
     return backend;
 }
 function createOperitBackend() {
-    const detected = NativeInterface;
+    // 必须用 typeof 探测：宿主不存在时（例如桌面 Node、或不在工具调用上下文里跑）
+    // 直接写 NativeInterface 会抛 ReferenceError，而不是本库的 ONJ_MISSING_HOST。
+    const detected = typeof NativeInterface === 'undefined' ? undefined : NativeInterface;
     if (detected === undefined) {
         throw (0, errors_1.onjError)('ONJ_MISSING_HOST');
     }

package/dist/lib/console-types.d.ts

@@ -0,0 +1,12 @@
+/** console 涉及的公开类型。 */
+/** 输出目标的最小形状：只要求 write。 */
+export interface WriteStreamLike {
+    write(chunk: string): unknown;
+}
+/** prelude 提供的 console；Node 下这里就是全局 console。 */
+export interface HostConsoleLike {
+    log(...args: unknown[]): void;
+    info(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+}

package/dist/lib/console-types.js

@@ -0,0 +1,2 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/diagnostics-channel-types.d.ts

@@ -0,0 +1,7 @@
+/** diagnostics_channel 的公开类型。 */
+export interface Subscriber {
+    (message: unknown, name: string): void;
+}
+export interface ChannelStore {
+    [key: string]: unknown;
+}

package/dist/lib/diagnostics-channel-types.js

@@ -0,0 +1,2 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/stream-consumers-types.d.ts

@@ -0,0 +1,4 @@
+/** stream/consumers 接受的最小可读流形状。 */
+export interface ReadableLike {
+    on(event: string, listener: (...args: unknown[]) => void): unknown;
+}

package/dist/lib/stream-consumers-types.js

@@ -0,0 +1,2 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/util-types.d.ts

@@ -0,0 +1,13 @@
+/** util.inspect 的选项（导出型别，供 console 等模块复用）。 */
+export interface InspectOptions {
+    depth?: number | null;
+    colors?: boolean;
+    showHidden?: boolean;
+    compact?: boolean | number;
+    breakLength?: number;
+    sorted?: boolean;
+    maxArrayLength?: number;
+    maxStringLength?: number | null;
+    getters?: boolean;
+    showProxy?: boolean;
+}

package/dist/lib/util-types.js

@@ -0,0 +1,2 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });