@serveryyswys/node.operit 0.0.0-stage → 0.1.2

package/dist/lib/deep-equal.js

@@ -0,0 +1,223 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDeepStrictEqual = isDeepStrictEqual;
+exports.isDeepEqual = isDeepEqual;
+/**
+ * 深比较，供 util.isDeepStrictEqual 与 assert.deepStrictEqual 共用。
+ *
+ * 目标是复刻 Node 的 `isDeepStrictEqual` 语义，几个容易漏的点：
+ *   - `+0` 与 `-0` 不相等（要 Object.is，不能只靠 ===）；
+ *   - `NaN` 相等；
+ *   - 比的是 constructor（沿原型链取）而不是原型对象本身：
+ *     `Object.create({i:1})` 与 `{}` 同类，`Object.create(null)` 与 `{}` 不同类；
+ *     数组与非数组永不相等（另有长度检查，所以 `[]` 与 `new Array(2)` 不等）；
+ *   - 循环引用要能终止（用 a->b 的 memo 对）；
+ *   - Map / Set 按"存在一个深比较相等的对应项"判断，且 Map 的键也参与深比较；
+ *   - 普通对象比较的是"自有可枚举字符串键 + 自有可枚举符号键"，
+ *     所以稀疏数组与补了 undefined 的数组不相等；
+ *   - Error 额外比较 name 与 message（它们是非枚举自有属性，Object.keys 看不到）。
+ */
+function tagOf(value) {
+    return Object.prototype.toString.call(value);
+}
+function isTypedArrayView(value) {
+    return ArrayBuffer.isView(value) && !(value instanceof DataView);
+}
+function bytesOf(view) {
+    return new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
+}
+function sameBytes(left, right) {
+    if (left.byteLength !== right.byteLength) {
+        return false;
+    }
+    const a = bytesOf(left);
+    const b = bytesOf(right);
+    for (let i = 0; i < a.length; i += 1) {
+        if (a[i] !== b[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+function ownEnumerableKeys(value, loose) {
+    const keys = Object.keys(value);
+    if (loose) {
+        // 旧版宽松深比较只看字符串键，不看符号键
+        return keys;
+    }
+    const symbols = Object.getOwnPropertySymbols(value);
+    for (let i = 0; i < symbols.length; i += 1) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, symbols[i]);
+        if (descriptor !== undefined && descriptor.enumerable === true) {
+            keys.push(symbols[i]);
+        }
+    }
+    return keys;
+}
+function readKey(value, key) {
+    return value[key];
+}
+function isDeepStrictEqual(left, right, loose) {
+    return inner(left, right, new Map(), loose === true);
+}
+function inner(left, right, seen, loose) {
+    if (left === right) {
+        // 宽松模式不区分 +0 / -0；严格模式要区分
+        return loose || left !== 0 || Object.is(left, right);
+    }
+    // 注意：函数不算"对象"—— Node 用的是 typeof x === 'object'，
+    // 所以两个不同的函数即使都没有自有键也不相等。
+    const leftIsObject = typeof left === 'object' && left !== null;
+    const rightIsObject = typeof right === 'object' && right !== null;
+    if (!leftIsObject || !rightIsObject) {
+        if (typeof left === 'number' && typeof right === 'number' && left !== left && right !== right) {
+            return true;
+        }
+        const leftNil = left === null || left === undefined;
+        const rightNil = right === null || right === undefined;
+        if (leftNil || rightNil) {
+            return loose && leftNil && rightNil;
+        }
+        const leftPrimitive = typeof left !== 'object' && typeof left !== 'function';
+        const rightPrimitive = typeof right !== 'object' && typeof right !== 'function';
+        if (loose && leftPrimitive && rightPrimitive) {
+            // 只有两侧都是原始值才用 ==：对 Object.create(null) 这类对象做 == 会抛
+            // "Cannot convert object to primitive value"。
+            // eslint-disable-next-line eqeqeq
+            return left == right;
+        }
+        return false;
+    }
+    // Node 比的是 constructor（沿原型链取），不是原型对象本身：
+    // 所以 Object.create({i:1}) 与 {} 视为同类，而 Object.create(null) 不是。
+    if (!loose) {
+        const leftConstructor = left.constructor;
+        const rightConstructor = right.constructor;
+        if (leftConstructor !== rightConstructor) {
+            return false;
+        }
+    }
+    // 数组与非数组是两类，即使 constructor 相同也不比
+    if (Array.isArray(left) !== Array.isArray(right)) {
+        return false;
+    }
+    const previous = seen.get(left);
+    if (previous !== undefined) {
+        return previous === right;
+    }
+    seen.set(left, right);
+    const leftTag = tagOf(left);
+    if (leftTag !== tagOf(right)) {
+        return false;
+    }
+    switch (leftTag) {
+        case '[object Date]':
+            return left.getTime() === right.getTime();
+        case '[object RegExp]':
+            return left.source === right.source &&
+                left.flags === right.flags;
+        case '[object Number]':
+        case '[object String]':
+        case '[object Boolean]':
+        case '[object Symbol]':
+        case '[object BigInt]':
+            return left.valueOf() === right.valueOf();
+        case '[object ArrayBuffer]':
+        case '[object SharedArrayBuffer]':
+            return sameBytes(new Uint8Array(left), new Uint8Array(right));
+        default:
+            break;
+    }
+    if (isTypedArrayView(left) && isTypedArrayView(right)) {
+        return sameBytes(left, right);
+    }
+    if (left instanceof DataView && right instanceof DataView) {
+        return sameBytes(left, right);
+    }
+    if (left instanceof Map && right instanceof Map) {
+        if (left.size !== right.size) {
+            return false;
+        }
+        const candidates = Array.from(right.entries());
+        const used = new Set();
+        for (const entry of left.entries()) {
+            let matched = false;
+            for (let i = 0; i < candidates.length; i += 1) {
+                if (used.has(i)) {
+                    continue;
+                }
+                if (inner(entry[0], candidates[i][0], seen, loose)) {
+                    if (!inner(entry[1], candidates[i][1], seen, loose)) {
+                        return false;
+                    }
+                    used.add(i);
+                    matched = true;
+                    break;
+                }
+            }
+            if (!matched) {
+                return false;
+            }
+        }
+        return true;
+    }
+    if (left instanceof Set && right instanceof Set) {
+        if (left.size !== right.size) {
+            return false;
+        }
+        const candidates = Array.from(right.values());
+        const used = new Set();
+        for (const value of left.values()) {
+            let matched = false;
+            for (let i = 0; i < candidates.length; i += 1) {
+                if (used.has(i)) {
+                    continue;
+                }
+                if (inner(value, candidates[i], seen, loose)) {
+                    used.add(i);
+                    matched = true;
+                    break;
+                }
+            }
+            if (!matched) {
+                return false;
+            }
+        }
+        return true;
+    }
+    if (left instanceof Error && right instanceof Error) {
+        if (left.name !== right.name || left.message !== right.message) {
+            return false;
+        }
+    }
+    // 数组还要比长度：[] 与 new Array(2) 的自有键都是空的，但 Node 认为不等
+    if (Array.isArray(left) && Array.isArray(right) && left.length !== right.length) {
+        return false;
+    }
+    const leftKeys = ownEnumerableKeys(left, loose);
+    const rightKeys = ownEnumerableKeys(right, loose);
+    if (leftKeys.length !== rightKeys.length) {
+        return false;
+    }
+    for (let i = 0; i < leftKeys.length; i += 1) {
+        const key = leftKeys[i];
+        let found = false;
+        for (let j = 0; j < rightKeys.length; j += 1) {
+            if (rightKeys[j] === key) {
+                found = true;
+                break;
+            }
+        }
+        if (!found) {
+            return false;
+        }
+        if (!inner(readKey(left, key), readKey(right, key), seen, loose)) {
+            return false;
+        }
+    }
+    return true;
+}
+/** Node 的旧版宽松深比较（assert.deepEqual），叶子用 == 且不检查原型。 */
+function isDeepEqual(left, right) {
+    return isDeepStrictEqual(left, right, true);
+}

package/dist/lib/deflate.d.ts

@@ -0,0 +1,2 @@
+/** 压缩为 raw DEFLATE 流。level <= 0 时退化为 stored 块。 */
+export declare function deflateRaw(data: Uint8Array, level: number): Uint8Array;

package/dist/lib/deflate.js

@@ -0,0 +1,234 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deflateRaw = deflateRaw;
+/**
+ * 纯 JS 的 DEFLATE 压缩（RFC 1951）。
+ *
+ * 策略：
+ *   level <= 0  -> 只用 stored 块（不压缩，但一定是合法流）
+ *   level > 0   -> 定长 Huffman 块 + LZ77（哈希链，链长随 level 增大）
+ *
+ * 没有实现动态 Huffman（那需要再写一套频率统计与码长编码），
+ * 因此压缩率不如 zlib，但**输出一定是任何解压器都能读的合法 DEFLATE 流** ——
+ * 这一点由 test/zlib.test.js 的"我们压的 Node 能解"方向验证。
+ */
+const LENGTH_BASE = [
+    3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
+    35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258
+];
+const LENGTH_EXTRA = [
+    0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2,
+    3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0
+];
+const DISTANCE_BASE = [
+    1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
+    257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577
+];
+const DISTANCE_EXTRA = [
+    0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6,
+    7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13
+];
+const WINDOW_SIZE = 32768;
+const MIN_MATCH = 3;
+const MAX_MATCH = 258;
+const HASH_BITS = 15;
+const HASH_SIZE = 1 << HASH_BITS;
+const HASH_MASK = HASH_SIZE - 1;
+function makeWriter(hint) {
+    return {
+        bytes: new Uint8Array(Math.max(64, hint)),
+        length: 0,
+        bits: 0,
+        bitCount: 0
+    };
+}
+function ensureCapacity(writer, extra) {
+    if (writer.length + extra <= writer.bytes.length) {
+        return;
+    }
+    let size = writer.bytes.length;
+    while (size < writer.length + extra) {
+        size *= 2;
+    }
+    const grown = new Uint8Array(size);
+    grown.set(writer.bytes.subarray(0, writer.length));
+    writer.bytes = grown;
+}
+/** DEFLATE 的位是"字节内低位优先"，所以按 LSB 累加。 */
+function writeBits(writer, value, count) {
+    writer.bits |= value << writer.bitCount;
+    writer.bitCount += count;
+    while (writer.bitCount >= 8) {
+        ensureCapacity(writer, 1);
+        writer.bytes[writer.length] = writer.bits & 0xff;
+        writer.length += 1;
+        writer.bits >>>= 8;
+        writer.bitCount -= 8;
+    }
+}
+/** Huffman 码本身是"高位优先"，所以逐位从最高位发出。 */
+function writeCode(writer, code, length) {
+    for (let i = length - 1; i >= 0; i -= 1) {
+        writeBits(writer, (code >> i) & 1, 1);
+    }
+}
+function writeFixedLiteral(writer, symbol) {
+    if (symbol < 144) {
+        writeCode(writer, 0x30 + symbol, 8);
+    }
+    else if (symbol < 256) {
+        writeCode(writer, 0x190 + (symbol - 144), 9);
+    }
+    else if (symbol < 280) {
+        writeCode(writer, symbol - 256, 7);
+    }
+    else {
+        writeCode(writer, 0xc0 + (symbol - 280), 8);
+    }
+}
+function writeFixedDistance(writer, symbol) {
+    writeCode(writer, symbol, 5);
+}
+function lengthIndex(length) {
+    for (let i = LENGTH_BASE.length - 1; i >= 0; i -= 1) {
+        if (length >= LENGTH_BASE[i]) {
+            return i;
+        }
+    }
+    return 0;
+}
+function distanceIndex(distance) {
+    for (let i = DISTANCE_BASE.length - 1; i >= 0; i -= 1) {
+        if (distance >= DISTANCE_BASE[i]) {
+            return i;
+        }
+    }
+    return 0;
+}
+function flushBits(writer) {
+    if (writer.bitCount > 0) {
+        ensureCapacity(writer, 1);
+        writer.bytes[writer.length] = writer.bits & 0xff;
+        writer.length += 1;
+        writer.bits = 0;
+        writer.bitCount = 0;
+    }
+}
+function writeStoredBlocks(writer, data) {
+    flushBits(writer);
+    let offset = 0;
+    const MAX_STORED = 65535;
+    if (data.length === 0) {
+        writeBits(writer, 1, 1);
+        writeBits(writer, 0, 2);
+        flushBits(writer);
+        ensureCapacity(writer, 4);
+        writer.bytes[writer.length] = 0;
+        writer.bytes[writer.length + 1] = 0;
+        writer.bytes[writer.length + 2] = 0xff;
+        writer.bytes[writer.length + 3] = 0xff;
+        writer.length += 4;
+        return;
+    }
+    while (offset < data.length) {
+        const size = Math.min(MAX_STORED, data.length - offset);
+        const isFinal = offset + size >= data.length ? 1 : 0;
+        writeBits(writer, isFinal, 1);
+        writeBits(writer, 0, 2);
+        flushBits(writer);
+        ensureCapacity(writer, 4 + size);
+        writer.bytes[writer.length] = size & 0xff;
+        writer.bytes[writer.length + 1] = (size >>> 8) & 0xff;
+        writer.bytes[writer.length + 2] = (~size) & 0xff;
+        writer.bytes[writer.length + 3] = ((~size) >>> 8) & 0xff;
+        writer.length += 4;
+        writer.bytes.set(data.subarray(offset, offset + size), writer.length);
+        writer.length += size;
+        offset += size;
+    }
+}
+function hashAt(data, position) {
+    const value = (data[position] << 16) ^ (data[position + 1] << 8) ^ data[position + 2];
+    return (value * 2654435761) >>> (32 - HASH_BITS) & HASH_MASK;
+}
+function writeCompressedBlock(writer, data, maxChain) {
+    const head = new Int32Array(HASH_SIZE).fill(-1);
+    const previous = new Int32Array(data.length).fill(-1);
+    writeBits(writer, 1, 1);
+    writeBits(writer, 1, 2);
+    let position = 0;
+    while (position < data.length) {
+        let bestLength = 0;
+        let bestDistance = 0;
+        if (position + MIN_MATCH <= data.length) {
+            const hash = hashAt(data, position);
+            let candidate = head[hash];
+            let chain = 0;
+            const limit = Math.max(0, position - WINDOW_SIZE);
+            while (candidate >= limit && candidate >= 0 && chain < maxChain) {
+                if (data[candidate] === data[position] &&
+                    data[candidate + 1] === data[position + 1] &&
+                    data[candidate + 2] === data[position + 2]) {
+                    let length = 0;
+                    const maxLength = Math.min(MAX_MATCH, data.length - position);
+                    while (length < maxLength && data[candidate + length] === data[position + length]) {
+                        length += 1;
+                    }
+                    if (length > bestLength) {
+                        bestLength = length;
+                        bestDistance = position - candidate;
+                        if (length === maxLength) {
+                            break;
+                        }
+                    }
+                }
+                candidate = previous[candidate];
+                chain += 1;
+            }
+        }
+        if (bestLength >= MIN_MATCH) {
+            const lIndex = lengthIndex(bestLength);
+            writeFixedLiteral(writer, 257 + lIndex);
+            if (LENGTH_EXTRA[lIndex] > 0) {
+                writeBits(writer, bestLength - LENGTH_BASE[lIndex], LENGTH_EXTRA[lIndex]);
+            }
+            const dIndex = distanceIndex(bestDistance);
+            writeFixedDistance(writer, dIndex);
+            if (DISTANCE_EXTRA[dIndex] > 0) {
+                writeBits(writer, bestDistance - DISTANCE_BASE[dIndex], DISTANCE_EXTRA[dIndex]);
+            }
+            for (let i = 0; i < bestLength; i += 1) {
+                const at = position + i;
+                if (at + MIN_MATCH <= data.length) {
+                    const hash = hashAt(data, at);
+                    previous[at] = head[hash];
+                    head[hash] = at;
+                }
+            }
+            position += bestLength;
+        }
+        else {
+            writeFixedLiteral(writer, data[position]);
+            if (position + MIN_MATCH <= data.length) {
+                const hash = hashAt(data, position);
+                previous[position] = head[hash];
+                head[hash] = position;
+            }
+            position += 1;
+        }
+    }
+    writeFixedLiteral(writer, 256);
+}
+/** 压缩为 raw DEFLATE 流。level <= 0 时退化为 stored 块。 */
+function deflateRaw(data, level) {
+    const writer = makeWriter(Math.max(64, Math.floor(data.length / 2)));
+    if (level <= 0) {
+        writeStoredBlocks(writer, data);
+        return writer.bytes.subarray(0, writer.length);
+    }
+    const normalized = Math.min(9, Math.floor(level));
+    const maxChain = normalized <= 1 ? 4 : (normalized <= 3 ? 8 : (normalized <= 6 ? 32 : 128));
+    writeCompressedBlock(writer, data, maxChain);
+    flushBits(writer);
+    return writer.bytes.subarray(0, writer.length);
+}

package/dist/lib/dns-driver.d.ts

@@ -0,0 +1,14 @@
+export interface AddressRecord {
+    address: string;
+    family: number;
+}
+export interface DnsDriver {
+    /** 对应 getaddrinfo：可能返回多条（IPv4 与 IPv6 都在）。失败时抛 Java 侧映射过的错误。 */
+    lookup(hostname: string): AddressRecord[];
+    /** 反向查询：地址 -> 规范主机名。 */
+    canonicalNameOf(address: string): string;
+}
+/** 宿主注入点：桌面测试用，传 null 恢复为 Operit Java 驱动。 */
+export declare function setDriver(next: DnsDriver | null): void;
+export declare function createJavaDriver(): DnsDriver;
+export declare function getDriver(): DnsDriver;

package/dist/lib/dns-driver.js

@@ -0,0 +1,85 @@
+'use strict';
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setDriver = setDriver;
+exports.createJavaDriver = createJavaDriver;
+exports.getDriver = getDriver;
+/**
+ * dns 的宿主驱动层：把"怎么把主机名解析成地址"收敛在一处，便于测试注入。
+ *
+ * 基于 java.net.InetAddress（即 getaddrinfo），这也是 dns.lookup 在 Node 里的实现路径。
+ * **记录级查询（resolveMx / resolveTxt 等）在 Android 上不成立**：
+ * 那需要 JNDI 的 DNS provider，而 com.sun.jndi.dns 不在 Android 里，
+ * 所以 dns.ts 对它们显式抛 ONJ_UNSUPPORTED，不做半个实现。
+ */
+const bridge = __importStar(require("./bridge"));
+const errors_1 = require("./errors");
+let driver = null;
+/** 宿主注入点：桌面测试用，传 null 恢复为 Operit Java 驱动。 */
+function setDriver(next) {
+    driver = next;
+}
+/** Java 可能给链路本地地址带上作用域（fe80::1%wlan0），Node 不给，这里去掉。 */
+function stripScope(address) {
+    const percent = address.indexOf('%');
+    return percent < 0 ? address : address.slice(0, percent);
+}
+function createJavaDriver() {
+    return {
+        lookup(hostname) {
+            const list = bridge.callStatic('java.net.InetAddress', 'getAllByName', [hostname]);
+            if (!Array.isArray(list)) {
+                throw (0, errors_1.createError)('EIO', 'getaddrinfo', hostname);
+            }
+            const out = [];
+            for (let i = 0; i < list.length; i += 1) {
+                const raw = String(bridge.callInstance(list[i], 'getHostAddress', []));
+                const address = stripScope(raw);
+                out.push({ address: address, family: address.indexOf(':') >= 0 ? 6 : 4 });
+            }
+            return out;
+        },
+        canonicalNameOf(address) {
+            const handle = bridge.callStatic('java.net.InetAddress', 'getByName', [address]);
+            return String(bridge.callInstance(handle, 'getCanonicalHostName', []));
+        }
+    };
+}
+function getDriver() {
+    if (driver === null) {
+        driver = createJavaDriver();
+    }
+    return driver;
+}

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

@@ -0,0 +1,22 @@
+/**
+ * dns 的公开类型。
+ *
+ * 独立成文件的原因与其他 types 文件相同：dns.ts 用 `export =` 导出模块本体，
+ * 而 dns/promises.ts 与它共用同一份 lookup 选项类型 —— 两处各写一份会互相泄漏无法命名。
+ */
+export interface LookupOptions {
+    family?: number;
+    hints?: number;
+    all?: boolean;
+    verbatim?: boolean;
+}
+export interface AddressRecord {
+    address: string;
+    family: number;
+}
+export interface DnsError extends Error {
+    code: string;
+    errno: number;
+    syscall: string;
+    hostname: string;
+}

package/dist/lib/dns-types.js

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

package/dist/lib/errors.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Node 错误码与 Java 异常之间的唯一翻译层。
+ *
+ * 设计约束：
+ * - 每个错误对象都必须带 code。三方库普遍靠 code 分支（fs.existsSync、mkdirp、tar 等），
+ *   没有 code 的实现等于跑不通。
+ * - Java 侧异常类名来自 bridge 的错误文本前缀，形如 "java.io.FileNotFoundException: /x"。
+ * - 未归类的 Java 异常一律映射为 EIO，并把原始类名与消息写进 message —— 这是明确定义的行为，
+ *   Node 自己的 fs 在无法归类的系统错误上也报 EIO。
+ */
+/** 与 Linux errno 对齐，供依赖 errno 数值的三方库使用。 */
+export declare const ERRNO: Readonly<Record<string, number>>;
+export interface NodeStyleError extends Error {
+    code: string;
+    errno?: number;
+    syscall?: string;
+    path?: string;
+    dest?: string;
+    cause?: unknown;
+    javaClass?: string;
+    javaMessage?: string;
+    isJavaError?: boolean;
+}
+export interface ParsedJavaError {
+    className: string;
+    message: string;
+}
+/** 构造一个 Node 形状的错误。syscall / path / dest 与 Node 自身的字段语义一致。 */
+export declare function createError(code: string, syscall: string, targetPath?: string, destPath?: string): NodeStyleError;
+/** node.operit 内部状态错误。 */
+export declare function onjError(code: string, detail?: string): NodeStyleError;
+/**
+ * 从 Java bridge 的错误文本里剥离异常类名。
+ * 形如 "java.io.FileNotFoundException: /sdcard/x" 或 "java.lang.SecurityException"。
+ */
+export declare function parseJavaError(text: string): ParsedJavaError;
+/**
+ * Java 异常类名 → Node 错误码。
+ * 先查精确表，再按消息特征识别少数几种，仍未命中则 EIO。
+ */
+export declare function codeForJavaException(className: string, javaMessage: string): string;
+/** 由 Java 错误文本构造中间态错误，保留原始类名与消息。 */
+export declare function javaError(text: string): NodeStyleError;
+/**
+ * 给中间态错误补上 syscall / path，产出语义完整的 Node 错误。
+ * 非 Java 错误原样返回。
+ */
+export declare function withContext(err: unknown, syscall: string, targetPath?: string, destPath?: string): unknown;