@serveryyswys/node.operit 0.0.0-stage → 0.1.2

package/dist/index.js

@@ -0,0 +1,57 @@
+'use strict';
+/**
+ * 聚合入口（糖）。
+ *
+ * 正式契约是"一个 Node 内置名 = 一个子路径"，见 BUILTINS.json；
+ * 本文件只把已实现的模块聚合成一个对象，方便手写代码时少写几行 require。
+ *
+ * 用法：
+ *     const onj = require('<项目>/node_modules/@serveryyswys/node.operit/index.js');
+ *     onj.path.join('a', 'b');
+ *
+ * 注意：stream 不在聚合里，因为它以类形式 `export =` 导出（`require('.../stream')` 返回
+ * Stream 类本身），无法在 .d.ts 里被"命名"，加进来会让本文件的声明生成失败。
+ * 需要它请直接引子路径。
+ */
+const pathModule = require("./path");
+const fsModule = require("./fs");
+const bufferModule = require("./buffer");
+const osModule = require("./os");
+const processModule = require("./process");
+const cryptoModule = require("./crypto");
+const zlibModule = require("./zlib");
+const childProcessModule = require("./child_process");
+const urlModule = require("./url");
+const timersModule = require("./timers");
+const timersPromisesModule = require("./timers/promises");
+const perfHooksModule = require("./perf_hooks");
+const constantsModule = require("./constants");
+const moduleModule = require("./module");
+const ttyModule = require("./tty");
+const httpModule = require("./http");
+const httpsModule = require("./https");
+const dnsModule = require("./dns");
+const dnsPromisesModule = require("./dns/promises");
+const api = {
+    version: '0.1.0',
+    path: pathModule,
+    fs: fsModule,
+    buffer: bufferModule,
+    os: osModule,
+    process: processModule,
+    crypto: cryptoModule,
+    zlib: zlibModule,
+    child_process: childProcessModule,
+    url: urlModule,
+    timers: timersModule,
+    'timers/promises': timersPromisesModule,
+    perf_hooks: perfHooksModule,
+    constants: constantsModule,
+    module: moduleModule,
+    tty: ttyModule,
+    http: httpModule,
+    https: httpsModule,
+    dns: dnsModule,
+    'dns/promises': dnsPromisesModule
+};
+module.exports = api;

package/dist/lib/bridge.d.ts

@@ -0,0 +1,60 @@
+/**
+ * 唯一接触 Operit Java bridge 的地方。
+ *
+ * 运行时契约（types/core.d.ts）：
+ *   javaCallStatic(className, methodName, argsJson) -> "{\"success\":bool,\"data\":any,\"error\":string}"
+ *   javaNewInstance / javaCallInstance / javaGet|SetStatic|InstanceField 同形状
+ *   javaGetApplicationContext / javaGetCurrentActivity
+ *
+ * 返回值经 toJsonCompatibleValue 转换：基本类型直通，数组 / Map / Iterable 递归展开，
+ * 其余对象变成 { __javaHandle, __javaClass } 句柄。参数方向只接受 JSON 值。
+ *
+ * 本模块只做三件事：调用、解包、把 Java 异常翻成带 code 的中间态错误。
+ * 它不知道 fs，也不知道路径语义 —— 那些属于上层。
+ */
+import { type NodeStyleError } from './errors';
+/** Java 侧对象在 JS 侧的表现形式。 */
+export interface JavaHandle {
+    __javaHandle: string;
+    __javaClass: string;
+}
+/** 宿主后端接口：Operit 上的实现走 NativeInterface，桌面测试注入 mock。 */
+export interface JavaBridgeBackend {
+    classExists(className: string): boolean;
+    callStatic(className: string, methodName: string, args: readonly unknown[]): unknown;
+    callInstance(instance: unknown, methodName: string, args: readonly unknown[]): unknown;
+    newInstance(className: string, args: readonly unknown[]): unknown;
+    getStaticField(className: string, fieldName: string): unknown;
+    setStaticField(className: string, fieldName: string, value: unknown): unknown;
+    getInstanceField(instance: unknown, fieldName: string): unknown;
+    setInstanceField(instance: unknown, fieldName: string, value: unknown): unknown;
+    getApplicationContext(): unknown;
+    getCurrentActivity(): unknown;
+    setEnv(key: string, value: string | null): void;
+}
+/** 宿主注入点：桌面测试与 mock 使用。传 null 恢复为自动解析 Operit 宿主。 */
+export declare function setBackend(next: JavaBridgeBackend | null): void;
+/** 把 { __javaHandle, __javaClass } 或裸 handle 字符串统一成 handle 字符串。 */
+export declare function handleOf(instance: unknown): string;
+export declare function normalizeBoolean(value: unknown): boolean;
+/**
+ * 解包 bridge 返回值。约定形状 `{ success, data?, error?, message? }`；
+ * success 为 false 时抛中间态 Java 错误（带 code，但还没有 syscall / path）。
+ */
+export declare function unwrap(raw: unknown, context: string): unknown;
+export declare function classExists(className: string): boolean;
+export declare function callStatic(className: string, methodName: string, args?: readonly unknown[]): unknown;
+export declare function callInstance(instance: unknown, methodName: string, args?: readonly unknown[]): unknown;
+export declare function newInstance(className: string, args?: readonly unknown[]): unknown;
+export declare function getStaticField(className: string, fieldName: string): unknown;
+export declare function setStaticField(className: string, fieldName: string, value: unknown): unknown;
+export declare function getInstanceField(instance: unknown, fieldName: string): unknown;
+export declare function setInstanceField(instance: unknown, fieldName: string, value: unknown): unknown;
+export declare function getApplicationContext(): unknown;
+export declare function getCurrentActivity(): unknown;
+/** 写环境变量。setEnv 是 P2 能力：不存在时抛 ONJ_MISSING_HOST，不静默丢弃。 */
+export declare function setEnv(key: string, value: string | null): void;
+/** 便于上层判断某个值是不是 Java 句柄。 */
+export declare function isJavaHandle(value: unknown): value is JavaHandle;
+/** 类型收窄辅助：把 unknown 断言成带 code 的错误对象。 */
+export declare function asNodeError(value: unknown): NodeStyleError | null;

package/dist/lib/bridge.js

@@ -0,0 +1,205 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setBackend = setBackend;
+exports.handleOf = handleOf;
+exports.normalizeBoolean = normalizeBoolean;
+exports.unwrap = unwrap;
+exports.classExists = classExists;
+exports.callStatic = callStatic;
+exports.callInstance = callInstance;
+exports.newInstance = newInstance;
+exports.getStaticField = getStaticField;
+exports.setStaticField = setStaticField;
+exports.getInstanceField = getInstanceField;
+exports.setInstanceField = setInstanceField;
+exports.getApplicationContext = getApplicationContext;
+exports.getCurrentActivity = getCurrentActivity;
+exports.setEnv = setEnv;
+exports.isJavaHandle = isJavaHandle;
+exports.asNodeError = asNodeError;
+/**
+ * 唯一接触 Operit Java bridge 的地方。
+ *
+ * 运行时契约（types/core.d.ts）：
+ *   javaCallStatic(className, methodName, argsJson) -> "{\"success\":bool,\"data\":any,\"error\":string}"
+ *   javaNewInstance / javaCallInstance / javaGet|SetStatic|InstanceField 同形状
+ *   javaGetApplicationContext / javaGetCurrentActivity
+ *
+ * 返回值经 toJsonCompatibleValue 转换：基本类型直通，数组 / Map / Iterable 递归展开，
+ * 其余对象变成 { __javaHandle, __javaClass } 句柄。参数方向只接受 JSON 值。
+ *
+ * 本模块只做三件事：调用、解包、把 Java 异常翻成带 code 的中间态错误。
+ * 它不知道 fs，也不知道路径语义 —— 那些属于上层。
+ */
+const errors_1 = require("./errors");
+let backend = null;
+/** 宿主注入点：桌面测试与 mock 使用。传 null 恢复为自动解析 Operit 宿主。 */
+function setBackend(next) {
+    backend = next === undefined ? null : next;
+}
+function getBackend() {
+    if (backend === null) {
+        backend = createOperitBackend();
+    }
+    return backend;
+}
+function createOperitBackend() {
+    const detected = NativeInterface;
+    if (detected === undefined) {
+        throw (0, errors_1.onjError)('ONJ_MISSING_HOST');
+    }
+    const native = detected;
+    function callNative(method, args) {
+        const fn = native[method];
+        if (typeof fn !== 'function') {
+            throw (0, errors_1.onjError)('ONJ_MISSING_HOST', 'NativeInterface.' + String(method) + ' 不可用。');
+        }
+        const invoke = fn;
+        return invoke.apply(native, args);
+    }
+    return {
+        classExists(className) {
+            return normalizeBoolean(callNative('javaClassExists', [String(className)]));
+        },
+        callStatic(className, methodName, args) {
+            return unwrap(callNative('javaCallStatic', [String(className), String(methodName), JSON.stringify(args)]), 'javaCallStatic ' + className + '#' + methodName);
+        },
+        callInstance(instance, methodName, args) {
+            return unwrap(callNative('javaCallInstance', [handleOf(instance), String(methodName), JSON.stringify(args)]), 'javaCallInstance ' + methodName);
+        },
+        newInstance(className, args) {
+            return unwrap(callNative('javaNewInstance', [String(className), JSON.stringify(args)]), 'javaNewInstance ' + className);
+        },
+        getStaticField(className, fieldName) {
+            return unwrap(callNative('javaGetStaticField', [String(className), String(fieldName)]), 'javaGetStaticField ' + className + '#' + fieldName);
+        },
+        setStaticField(className, fieldName, value) {
+            return unwrap(callNative('javaSetStaticField', [String(className), String(fieldName), JSON.stringify(value)]), 'javaSetStaticField ' + className + '#' + fieldName);
+        },
+        getInstanceField(instance, fieldName) {
+            return unwrap(callNative('javaGetInstanceField', [handleOf(instance), String(fieldName)]), 'javaGetInstanceField ' + fieldName);
+        },
+        setInstanceField(instance, fieldName, value) {
+            return unwrap(callNative('javaSetInstanceField', [handleOf(instance), String(fieldName), JSON.stringify(value)]), 'javaSetInstanceField ' + fieldName);
+        },
+        getApplicationContext() {
+            return unwrap(callNative('javaGetApplicationContext', []), 'javaGetApplicationContext');
+        },
+        getCurrentActivity() {
+            return unwrap(callNative('javaGetCurrentActivity', []), 'javaGetCurrentActivity');
+        },
+        setEnv(key, value) {
+            // setEnv 属于 P2（源码里真实存在，官方 d.ts 未声明），因此显式检查可用性
+            if (typeof native.setEnv !== 'function') {
+                throw (0, errors_1.onjError)('ONJ_MISSING_HOST', 'NativeInterface.setEnv 不可用，无法写环境变量。');
+            }
+            native.setEnv(String(key), value);
+        }
+    };
+}
+/** 把 { __javaHandle, __javaClass } 或裸 handle 字符串统一成 handle 字符串。 */
+function handleOf(instance) {
+    if (typeof instance === 'string' && instance.length > 0) {
+        return instance;
+    }
+    if (instance !== null && typeof instance === 'object') {
+        const candidate = instance.__javaHandle;
+        if (typeof candidate === 'string' && candidate.length > 0) {
+            return candidate;
+        }
+    }
+    throw (0, errors_1.createError)('EINVAL', 'bridge.handleOf');
+}
+function normalizeBoolean(value) {
+    if (value === true || value === false) {
+        return value;
+    }
+    if (typeof value === 'string') {
+        return value.trim().toLowerCase() === 'true';
+    }
+    if (typeof value === 'number') {
+        return value !== 0;
+    }
+    if (value === null || value === undefined) {
+        return false;
+    }
+    return Boolean(value);
+}
+/**
+ * 解包 bridge 返回值。约定形状 `{ success, data?, error?, message? }`；
+ * success 为 false 时抛中间态 Java 错误（带 code，但还没有 syscall / path）。
+ */
+function unwrap(raw, context) {
+    if (typeof raw !== 'string') {
+        return raw;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (parseFailure) {
+        throw (0, errors_1.onjError)('ONJ_BRIDGE_PROTOCOL', context + ' 的返回不是 JSON。');
+    }
+    if (parsed === null || typeof parsed !== 'object') {
+        return parsed;
+    }
+    const envelope = parsed;
+    if (envelope.success === false) {
+        const detail = typeof envelope.error === 'string' && envelope.error.length > 0
+            ? envelope.error
+            : (typeof envelope.message === 'string' && envelope.message.length > 0 ? envelope.message : context);
+        throw (0, errors_1.javaError)(detail);
+    }
+    if (Object.prototype.hasOwnProperty.call(envelope, 'data')) {
+        return envelope.data;
+    }
+    return envelope;
+}
+function classExists(className) {
+    return getBackend().classExists(className);
+}
+function callStatic(className, methodName, args = []) {
+    return getBackend().callStatic(className, methodName, args);
+}
+function callInstance(instance, methodName, args = []) {
+    return getBackend().callInstance(instance, methodName, args);
+}
+function newInstance(className, args = []) {
+    return getBackend().newInstance(className, args);
+}
+function getStaticField(className, fieldName) {
+    return getBackend().getStaticField(className, fieldName);
+}
+function setStaticField(className, fieldName, value) {
+    return getBackend().setStaticField(className, fieldName, value);
+}
+function getInstanceField(instance, fieldName) {
+    return getBackend().getInstanceField(instance, fieldName);
+}
+function setInstanceField(instance, fieldName, value) {
+    return getBackend().setInstanceField(instance, fieldName, value);
+}
+function getApplicationContext() {
+    return getBackend().getApplicationContext();
+}
+function getCurrentActivity() {
+    return getBackend().getCurrentActivity();
+}
+/** 写环境变量。setEnv 是 P2 能力：不存在时抛 ONJ_MISSING_HOST，不静默丢弃。 */
+function setEnv(key, value) {
+    getBackend().setEnv(key, value);
+}
+/** 便于上层判断某个值是不是 Java 句柄。 */
+function isJavaHandle(value) {
+    if (value === null || typeof value !== 'object') {
+        return false;
+    }
+    return typeof value.__javaHandle === 'string';
+}
+/** 类型收窄辅助：把 unknown 断言成带 code 的错误对象。 */
+function asNodeError(value) {
+    if (value instanceof Error) {
+        return value;
+    }
+    return null;
+}

package/dist/lib/bytes.d.ts

@@ -0,0 +1,20 @@
+export type BinaryChannel = 'base64' | 'latin1';
+export declare function encodeBase64(bytes: Uint8Array): string;
+/**
+ * 按 Node 的容错规则解码 base64：
+ *   - 字母表以外的 ASCII 字符（空白、'!' 等）跳过
+ *   - 遇到 '=' 或任何码点 > 0x7f 的字符立即停止
+ * 于是 'aGVsbG8=' 与 'aGVs bG8=!' 同结果，而 'a=b' 与 '🚀 emoji' 都是空。
+ * 对规范 base64 输入（本库自己的编码器产物）结果与严格解码完全一致。
+ */
+export declare function decodeBase64(text: string): Uint8Array;
+export declare function bytesToLatin1(bytes: Uint8Array): string;
+export declare function latin1ToBytes(text: string): Uint8Array;
+export declare function utf8Encode(text: string): Uint8Array;
+export declare function utf8Decode(bytes: Uint8Array): string;
+export declare function getChannel(): BinaryChannel;
+export declare function setChannel(name: BinaryChannel): void;
+/** 按当前通道把字节编码成可穿过 bridge 的字符串。 */
+export declare function encode(bytes: Uint8Array): string;
+/** 按当前通道把 bridge 返回的字符串还原成字节。 */
+export declare function decode(text: string): Uint8Array;

package/dist/lib/bytes.js

@@ -0,0 +1,239 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeBase64 = encodeBase64;
+exports.decodeBase64 = decodeBase64;
+exports.bytesToLatin1 = bytesToLatin1;
+exports.latin1ToBytes = latin1ToBytes;
+exports.utf8Encode = utf8Encode;
+exports.utf8Decode = utf8Decode;
+exports.getChannel = getChannel;
+exports.setChannel = setChannel;
+exports.encode = encode;
+exports.decode = decode;
+/**
+ * 二进制通道的唯一开关，以及 UTF-8 编解码。
+ *
+ * 背景：Java bridge 的返回值经 toJsonCompatibleValue 转换，byte[] 会被逐元素展开成
+ * JSON 数字数组（1MB 文件膨胀到 MB 级文本），因此二进制不走 byte[]，改用字符串通道：
+ *
+ *   base64  1.33x 体积，纯 ASCII，任何传输都安全 —— 默认
+ *   latin1  1.00x 体积，依赖 JSON 字符串保持码点不变
+ *
+ * 换通道只改这里；fs 与 Buffer 都只调 encode() / decode()。
+ * QuickJS 不保证有 TextEncoder / TextDecoder，因此 UTF-8 自行实现，非法序列按 U+FFFD 处理。
+ */
+const errors_1 = require("./errors");
+const ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+const LOOKUP = (function buildLookup() {
+    const table = new Int16Array(128);
+    for (let i = 0; i < table.length; i += 1) {
+        table[i] = -1;
+    }
+    for (let j = 0; j < ALPHABET.length; j += 1) {
+        table[ALPHABET.charCodeAt(j)] = j;
+    }
+    return table;
+})();
+const REPLACEMENT_CODE_POINT = 0xfffd;
+const CHAR_EQUALS = 61;
+function encodeBase64(bytes) {
+    let out = '';
+    const len = bytes.length;
+    let i = 0;
+    for (; i + 2 < len; i += 3) {
+        const triple = (bytes[i] << 16) | (bytes[i + 1] << 8) | bytes[i + 2];
+        out += ALPHABET[(triple >> 18) & 63] +
+            ALPHABET[(triple >> 12) & 63] +
+            ALPHABET[(triple >> 6) & 63] +
+            ALPHABET[triple & 63];
+    }
+    const rest = len - i;
+    if (rest === 1) {
+        const single = bytes[i] << 16;
+        out += ALPHABET[(single >> 18) & 63] + ALPHABET[(single >> 12) & 63] + '==';
+    }
+    else if (rest === 2) {
+        const pair = (bytes[i] << 16) | (bytes[i + 1] << 8);
+        out += ALPHABET[(pair >> 18) & 63] +
+            ALPHABET[(pair >> 12) & 63] +
+            ALPHABET[(pair >> 6) & 63] + '=';
+    }
+    return out;
+}
+/**
+ * 按 Node 的容错规则解码 base64：
+ *   - 字母表以外的 ASCII 字符（空白、'!' 等）跳过
+ *   - 遇到 '=' 或任何码点 > 0x7f 的字符立即停止
+ * 于是 'aGVsbG8=' 与 'aGVs bG8=!' 同结果，而 'a=b' 与 '🚀 emoji' 都是空。
+ * 对规范 base64 输入（本库自己的编码器产物）结果与严格解码完全一致。
+ */
+function decodeBase64(text) {
+    const source = String(text);
+    let count = 0;
+    for (let i = 0; i < source.length; i += 1) {
+        const code = source.charCodeAt(i);
+        if (code === CHAR_EQUALS || code > 0x7f) {
+            break;
+        }
+        if (LOOKUP[code] >= 0) {
+            count += 1;
+        }
+    }
+    const remainder = count & 3;
+    let outLength = (count >> 2) * 3;
+    if (remainder === 2) {
+        outLength += 1;
+    }
+    else if (remainder === 3) {
+        outLength += 2;
+    }
+    const out = new Uint8Array(outLength);
+    let accumulator = 0;
+    let inWindow = 0;
+    let produced = 0;
+    let o = 0;
+    for (let i = 0; i < source.length && produced < count; i += 1) {
+        const code = source.charCodeAt(i);
+        if (code === CHAR_EQUALS || code > 0x7f) {
+            break;
+        }
+        const value = LOOKUP[code];
+        if (value < 0) {
+            continue;
+        }
+        accumulator = (accumulator << 6) | value;
+        inWindow += 1;
+        produced += 1;
+        if (inWindow === 4) {
+            out[o] = (accumulator >> 16) & 255;
+            out[o + 1] = (accumulator >> 8) & 255;
+            out[o + 2] = accumulator & 255;
+            o += 3;
+            accumulator = 0;
+            inWindow = 0;
+        }
+    }
+    if (inWindow === 2) {
+        out[o] = (accumulator >> 4) & 255;
+    }
+    else if (inWindow === 3) {
+        out[o] = (accumulator >> 10) & 255;
+        out[o + 1] = (accumulator >> 2) & 255;
+    }
+    return out;
+}
+function bytesToLatin1(bytes) {
+    const parts = [];
+    const CHUNK = 4096;
+    for (let i = 0; i < bytes.length; i += CHUNK) {
+        const end = Math.min(i + CHUNK, bytes.length);
+        const chunk = new Array(end - i);
+        for (let j = i; j < end; j += 1) {
+            chunk[j - i] = bytes[j];
+        }
+        parts.push(String.fromCharCode.apply(null, chunk));
+    }
+    return parts.join('');
+}
+function latin1ToBytes(text) {
+    const source = String(text);
+    const out = new Uint8Array(source.length);
+    for (let i = 0; i < source.length; i += 1) {
+        out[i] = source.charCodeAt(i) & 255;
+    }
+    return out;
+}
+function utf8Encode(text) {
+    const source = String(text);
+    const out = [];
+    for (let i = 0; i < source.length; i += 1) {
+        const code = source.charCodeAt(i);
+        if (code < 0x80) {
+            out.push(code);
+        }
+        else if (code < 0x800) {
+            out.push(0xc0 | (code >> 6), 0x80 | (code & 63));
+        }
+        else if (code >= 0xd800 && code <= 0xdbff) {
+            const low = i + 1 < source.length ? source.charCodeAt(i + 1) : 0;
+            if (low >= 0xdc00 && low <= 0xdfff) {
+                i += 1;
+                const codePoint = 0x10000 + ((code - 0xd800) << 10) + (low - 0xdc00);
+                out.push(0xf0 | (codePoint >> 18), 0x80 | ((codePoint >> 12) & 63), 0x80 | ((codePoint >> 6) & 63), 0x80 | (codePoint & 63));
+            }
+            else {
+                out.push(0xef, 0xbf, 0xbd);
+            }
+        }
+        else if (code >= 0xdc00 && code <= 0xdfff) {
+            out.push(0xef, 0xbf, 0xbd);
+        }
+        else {
+            out.push(0xe0 | (code >> 12), 0x80 | ((code >> 6) & 63), 0x80 | (code & 63));
+        }
+    }
+    return new Uint8Array(out);
+}
+function utf8Decode(bytes) {
+    let out = '';
+    let i = 0;
+    const len = bytes.length;
+    while (i < len) {
+        const b0 = bytes[i];
+        if (b0 < 0x80) {
+            out += String.fromCharCode(b0);
+            i += 1;
+            continue;
+        }
+        if (b0 >= 0xc2 && b0 <= 0xdf && i + 1 < len && (bytes[i + 1] & 0xc0) === 0x80) {
+            out += String.fromCharCode(((b0 & 0x1f) << 6) | (bytes[i + 1] & 63));
+            i += 2;
+            continue;
+        }
+        if (b0 >= 0xe0 && b0 <= 0xef && i + 2 < len &&
+            (bytes[i + 1] & 0xc0) === 0x80 && (bytes[i + 2] & 0xc0) === 0x80) {
+            const cp3 = ((b0 & 0x0f) << 12) | ((bytes[i + 1] & 63) << 6) | (bytes[i + 2] & 63);
+            if (cp3 >= 0x800 && !(cp3 >= 0xd800 && cp3 <= 0xdfff)) {
+                out += String.fromCharCode(cp3);
+                i += 3;
+                continue;
+            }
+        }
+        if (b0 >= 0xf0 && b0 <= 0xf4 && i + 3 < len &&
+            (bytes[i + 1] & 0xc0) === 0x80 &&
+            (bytes[i + 2] & 0xc0) === 0x80 &&
+            (bytes[i + 3] & 0xc0) === 0x80) {
+            const cp4 = ((b0 & 0x07) << 18) |
+                ((bytes[i + 1] & 63) << 12) |
+                ((bytes[i + 2] & 63) << 6) |
+                (bytes[i + 3] & 63);
+            if (cp4 >= 0x10000 && cp4 <= 0x10ffff) {
+                const offset = cp4 - 0x10000;
+                out += String.fromCharCode(0xd800 + (offset >> 10), 0xdc00 + (offset & 0x3ff));
+                i += 4;
+                continue;
+            }
+        }
+        out += String.fromCharCode(REPLACEMENT_CODE_POINT);
+        i += 1;
+    }
+    return out;
+}
+let channel = 'base64';
+function getChannel() {
+    return channel;
+}
+function setChannel(name) {
+    if (name !== 'base64' && name !== 'latin1') {
+        throw (0, errors_1.onjError)('ONJ_BRIDGE_PROTOCOL', '未知的二进制通道: ' + String(name));
+    }
+    channel = name;
+}
+/** 按当前通道把字节编码成可穿过 bridge 的字符串。 */
+function encode(bytes) {
+    return channel === 'base64' ? encodeBase64(bytes) : bytesToLatin1(bytes);
+}
+/** 按当前通道把 bridge 返回的字符串还原成字节。 */
+function decode(text) {
+    return channel === 'base64' ? decodeBase64(text) : latin1ToBytes(text);
+}

package/dist/lib/child-process-types.d.ts

@@ -0,0 +1,45 @@
+/**
+ * child_process 的公开类型。
+ *
+ * 与其他 types 文件同样的原因：child_process.ts 用 `export =` 导出模块本体，
+ * 无法再导出类型。
+ */
+import type { NodeStyleError } from './errors';
+import type { Buffer } from '../buffer';
+/** 驱动层一次执行的完整结果（含启动失败）。 */
+export interface RunOutcome {
+    pid: number;
+    status: number | null;
+    signal: string | null;
+    stdout: Buffer;
+    stderr: Buffer;
+    error?: NodeStyleError;
+}
+export interface ExecOptions {
+    cwd?: string;
+    env?: Record<string, string>;
+    encoding?: string;
+    timeout?: number;
+    maxBuffer?: number;
+    shell?: string | boolean;
+    windowsHide?: boolean;
+}
+export interface SpawnSyncResult {
+    pid: number;
+    output: Array<unknown>;
+    stdout: unknown;
+    stderr: unknown;
+    status: number | null;
+    signal: string | null;
+    error?: Error;
+}
+export interface ExecException extends Error {
+    code?: string;
+    status?: number | null;
+    signal?: string | null;
+    stdout?: unknown;
+    stderr?: unknown;
+    pid?: number;
+    killed?: boolean;
+}
+export type ExecCallback = (error: ExecException | null, stdout?: unknown, stderr?: unknown) => void;

package/dist/lib/child-process-types.js

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

package/dist/lib/cwd.d.ts

@@ -0,0 +1,2 @@
+export declare function get(): string;
+export declare function set(next: string): void;

package/dist/lib/cwd.js

@@ -0,0 +1,32 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.get = get;
+exports.set = set;
+/**
+ * 当前工作目录的唯一持有者。
+ *
+ * path.resolve 需要 cwd，而 cwd 的语义由 fs 的环境状态机决定（环境 = 根 + cwd + 能力）。
+ * 独立成模块是为了打破 path 与 fs 之间的循环依赖：path 只读，fs / process 只写。
+ */
+let current = '/';
+function get() {
+    return current;
+}
+function set(next) {
+    if (typeof next !== 'string' || next.length === 0) {
+        throw new TypeError('cwd 必须是非空字符串，收到 ' + describe(next));
+    }
+    current = next;
+}
+function describe(value) {
+    if (typeof value === 'string') {
+        return "'" + value + "'";
+    }
+    if (value === null) {
+        return 'null';
+    }
+    if (value === undefined) {
+        return 'undefined';
+    }
+    return String(value);
+}

package/dist/lib/deep-equal.d.ts

@@ -0,0 +1,3 @@
+export declare function isDeepStrictEqual(left: unknown, right: unknown, loose?: boolean): boolean;
+/** Node 的旧版宽松深比较（assert.deepEqual），叶子用 == 且不检查原型。 */
+export declare function isDeepEqual(left: unknown, right: unknown): boolean;