@serveryyswys/node.operit 0.0.0-stage → 0.1.2

package/dist/lib/fs-driver.js

@@ -0,0 +1,364 @@
+'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.getDriver = getDriver;
+exports.createJavaDriver = createJavaDriver;
+/**
+ * fs 的宿主驱动层：把"文件系统原语"与"Node 语义"分开。
+ *
+ * fs.ts 只做 Node 语义（选项解析、错误码、返回值形状），所有真正的 I/O 都走本接口。
+ * 这样：
+ *   - 桌面测试可以注入一个基于 Node fs 的驱动，从而**把 fs.ts 的语义与 Node 对拍**；
+ *   - Java 相关的假设全部收敛在 createJavaDriver() 里，真机验证只需针对这一处。
+ *
+ * 驱动抛出的错误是 bridge 的中间态 Java 错误（带 code），由 fs.ts 补 syscall / path。
+ */
+const bridge = __importStar(require("./bridge"));
+const errors_1 = require("./errors");
+const bytesCodec = __importStar(require("./bytes"));
+let driver = null;
+/** 宿主注入点：桌面测试用，传 null 恢复为 Operit Java 驱动。 */
+function setDriver(next) {
+    driver = next;
+}
+function getDriver() {
+    if (driver === null) {
+        driver = createJavaDriver();
+    }
+    return driver;
+}
+// ------------------------------------------------------------------ Java 实现
+const DEFAULT_MODE_FILE = 0o666;
+const DEFAULT_MODE_DIR = 0o777;
+/**
+ * 基于 java.io.File / java.nio.file.Files / java.io.RandomAccessFile 的驱动。
+ *
+ * 通道选择（对应 DESIGN.md §6.3）：
+ *   - 读：Files.readAllBytes(Path) 返回 byte[]，bridge 会展开成 JSON 数字数组，直接用
+ *   - 写：RandomAccessFile.writeBytes(String) 写每个字符的低 8 位 —— 正好是 latin1 通道，
+ *         避免了"把 JS 数组当 byte[] 参数传进去"这类未验证行为
+ *
+ * 已知近似（真机验证时要确认）：
+ *   - atime / ctime / birthtime 都取 lastModified
+ *   - mode 按类型给默认值，不反映真实权限位
+ *   - readdir 不区分符号链接
+ */
+function createJavaDriver() {
+    function fileOf(target) {
+        return bridge.newInstance('java.io.File', [target]);
+    }
+    function pathOf(target) {
+        return bridge.callInstance(fileOf(target), 'toPath', []);
+    }
+    function callFile(target, method, args = []) {
+        return bridge.callInstance(fileOf(target), method, args);
+    }
+    function readAllBytes(target) {
+        const raw = bridge.callStatic('java.nio.file.Files', 'readAllBytes', [pathOf(target)]);
+        if (!Array.isArray(raw)) {
+            throw (0, errors_1.createError)('EIO', 'read');
+        }
+        const out = new Uint8Array(raw.length);
+        for (let i = 0; i < raw.length; i += 1) {
+            out[i] = raw[i] & 255;
+        }
+        return out;
+    }
+    function writeAllBytes(target, data, append, exclusive) {
+        if (exclusive && callFile(target, 'exists')) {
+            throw (0, errors_1.javaError)('java.nio.file.FileAlreadyExistsException: ' + target);
+        }
+        const handle = bridge.newInstance('java.io.RandomAccessFile', [target, 'rw']);
+        try {
+            if (append) {
+                bridge.callInstance(handle, 'seek', [bridge.callInstance(handle, 'length', [])]);
+            }
+            else {
+                bridge.callInstance(handle, 'setLength', [0]);
+            }
+            bridge.callInstance(handle, 'writeBytes', [bytesCodec.bytesToLatin1(data)]);
+        }
+        finally {
+            bridge.callInstance(handle, 'close', []);
+        }
+    }
+    function describe(target, followLinks) {
+        if (!callFile(target, 'exists')) {
+            throw (0, errors_1.javaError)('java.io.FileNotFoundException: ' + target);
+        }
+        const isLink = followLinks ? false : bridge.normalizeBoolean(bridge.callStatic('java.nio.file.Files', 'isSymbolicLink', [pathOf(target)]));
+        const isDirectory = bridge.normalizeBoolean(callFile(target, 'isDirectory'));
+        const isFile = bridge.normalizeBoolean(callFile(target, 'isFile'));
+        const size = Number(callFile(target, 'length')) || 0;
+        const modified = Number(callFile(target, 'lastModified')) || 0;
+        return {
+            isFile: isFile,
+            isDirectory: isDirectory,
+            isSymbolicLink: isLink,
+            size: isFile ? size : 0,
+            mode: isDirectory ? DEFAULT_MODE_DIR : DEFAULT_MODE_FILE,
+            atimeMs: modified,
+            mtimeMs: modified,
+            ctimeMs: modified,
+            birthtimeMs: modified
+        };
+    }
+    function removeRecursive(target) {
+        const handle = fileOf(target);
+        if (!bridge.normalizeBoolean(bridge.callInstance(handle, 'exists', []))) {
+            return;
+        }
+        if (bridge.normalizeBoolean(bridge.callInstance(handle, 'isDirectory', []))) {
+            const children = bridge.callInstance(handle, 'listFiles', []);
+            if (Array.isArray(children)) {
+                for (let i = 0; i < children.length; i += 1) {
+                    removeRecursive(String(bridge.callInstance(children[i], 'getAbsolutePath', [])));
+                }
+            }
+        }
+        bridge.callInstance(handle, 'delete', []);
+    }
+    /**
+     * fd 句柄基于 java.io.RandomAccessFile：
+     *   - 读：FileChannel.read(ByteBuffer, position) —— ByteBuffer.array() 能把数据**返回**出来，
+     *     避免"把 byte[] 当参数传进去、靠 Java 原地修改"这种在 bridge 上不可见的行为；
+     *   - 写：seek + writeBytes(String)，写每个字符的低 8 位，正好是 latin1 通道。
+     */
+    function openHandle(target, options) {
+        if (options.exclusive && bridge.normalizeBoolean(callFile(target, 'exists'))) {
+            throw (0, errors_1.javaError)('java.nio.file.FileAlreadyExistsException: ' + target);
+        }
+        const handle = bridge.newInstance('java.io.RandomAccessFile', [target, options.writable ? 'rw' : 'r']);
+        const channel = bridge.callInstance(handle, 'getChannel', []);
+        if (options.truncate) {
+            bridge.callInstance(handle, 'setLength', [0]);
+        }
+        if (options.append) {
+            bridge.callInstance(handle, 'seek', [bridge.callInstance(handle, 'length', [])]);
+        }
+        return {
+            read(position, length) {
+                if (length <= 0) {
+                    return new Uint8Array(0);
+                }
+                const buffer = bridge.callStatic('java.nio.ByteBuffer', 'allocate', [length]);
+                const start = position === null
+                    ? Number(bridge.callInstance(handle, 'getFilePointer', []))
+                    : position;
+                const count = Number(bridge.callInstance(channel, 'read', [buffer, start]));
+                if (position === null) {
+                    bridge.callInstance(handle, 'seek', [start + (isFinite(count) ? count : 0)]);
+                }
+                if (!isFinite(count) || count <= 0) {
+                    return new Uint8Array(0);
+                }
+                const raw = bridge.callInstance(buffer, 'array', []);
+                if (!Array.isArray(raw)) {
+                    return new Uint8Array(0);
+                }
+                const usable = Math.min(count, raw.length);
+                const out = new Uint8Array(usable);
+                for (let i = 0; i < usable; i += 1) {
+                    out[i] = raw[i] & 255;
+                }
+                return out;
+            },
+            write(position, data) {
+                const pointer = Number(bridge.callInstance(handle, 'getFilePointer', []));
+                const start = position === null ? pointer : position;
+                bridge.callInstance(handle, 'seek', [start]);
+                bridge.callInstance(handle, 'writeBytes', [bytesCodec.bytesToLatin1(data)]);
+                const advanced = Number(bridge.callInstance(handle, 'getFilePointer', []));
+                if (position !== null) {
+                    // Node 语义：带 position 的写不改变文件位置
+                    bridge.callInstance(handle, 'seek', [pointer]);
+                }
+                return advanced - start;
+            },
+            size() {
+                return Number(bridge.callInstance(handle, 'length', [])) || 0;
+            },
+            truncate(length) {
+                bridge.callInstance(handle, 'setLength', [length]);
+            },
+            sync() {
+                bridge.callInstance(bridge.callInstance(handle, 'getFD', []), 'sync', []);
+            },
+            close() {
+                bridge.callInstance(handle, 'close', []);
+            }
+        };
+    }
+    return {
+        openHandle: openHandle,
+        stat(target, followLinks) {
+            return describe(target, followLinks);
+        },
+        exists(target) {
+            return bridge.normalizeBoolean(callFile(target, 'exists'));
+        },
+        readdir(target) {
+            if (!bridge.normalizeBoolean(callFile(target, 'isDirectory'))) {
+                if (callFile(target, 'exists')) {
+                    throw (0, errors_1.javaError)('java.nio.file.NotDirectoryException: ' + target);
+                }
+                throw (0, errors_1.javaError)('java.io.FileNotFoundException: ' + target);
+            }
+            const children = callFile(target, 'listFiles');
+            if (!Array.isArray(children)) {
+                return [];
+            }
+            const out = [];
+            for (let i = 0; i < children.length; i += 1) {
+                const child = children[i];
+                out.push({
+                    name: String(bridge.callInstance(child, 'getName', [])),
+                    isFile: bridge.normalizeBoolean(bridge.callInstance(child, 'isFile', [])),
+                    isDirectory: bridge.normalizeBoolean(bridge.callInstance(child, 'isDirectory', [])),
+                    isSymbolicLink: false
+                });
+            }
+            return out;
+        },
+        readFileBytes(target) {
+            return readAllBytes(target);
+        },
+        writeFileBytes(target, data, append, exclusive) {
+            writeAllBytes(target, data, append, exclusive);
+        },
+        mkdir(target, recursive) {
+            if (recursive) {
+                const parent = bridge.callInstance(fileOf(target), 'getParent', []);
+                const created = bridge.normalizeBoolean(callFile(target, 'mkdirs'));
+                if (!created && !callFile(target, 'isDirectory')) {
+                    throw (0, errors_1.javaError)('java.io.IOException: Cannot create directory ' + target);
+                }
+                return created ? (typeof parent === 'string' ? target : target) : undefined;
+            }
+            const ok = bridge.normalizeBoolean(callFile(target, 'mkdir'));
+            if (!ok) {
+                if (callFile(target, 'exists')) {
+                    throw (0, errors_1.javaError)('java.nio.file.FileAlreadyExistsException: ' + target);
+                }
+                throw (0, errors_1.javaError)('java.io.IOException: Cannot create directory ' + target);
+            }
+            return undefined;
+        },
+        remove(target, recursive, force) {
+            const handle = fileOf(target);
+            if (!bridge.normalizeBoolean(bridge.callInstance(handle, 'exists', []))) {
+                if (force) {
+                    return;
+                }
+                throw (0, errors_1.javaError)('java.io.FileNotFoundException: ' + target);
+            }
+            const isDirectory = bridge.normalizeBoolean(bridge.callInstance(handle, 'isDirectory', []));
+            if (isDirectory && !recursive) {
+                const children = bridge.callInstance(handle, 'listFiles', []);
+                if (Array.isArray(children) && children.length > 0) {
+                    throw (0, errors_1.javaError)('java.nio.file.DirectoryNotEmptyException: ' + target);
+                }
+            }
+            if (isDirectory && recursive) {
+                removeRecursive(target);
+                return;
+            }
+            bridge.callInstance(handle, 'delete', []);
+        },
+        rename(from, to) {
+            const moved = bridge.normalizeBoolean(bridge.callInstance(fileOf(from), 'renameTo', [fileOf(to)]));
+            if (!moved) {
+                throw (0, errors_1.javaError)('java.io.IOException: Cannot rename ' + from + ' to ' + to);
+            }
+        },
+        copyFile(from, to) {
+            writeAllBytes(to, readAllBytes(from), false, false);
+        },
+        realpath(target) {
+            const resolved = callFile(target, 'getCanonicalPath');
+            if (typeof resolved !== 'string' || resolved.length === 0) {
+                throw (0, errors_1.javaError)('java.io.FileNotFoundException: ' + target);
+            }
+            return resolved;
+        },
+        readlink(target) {
+            const resolved = bridge.callStatic('java.nio.file.Files', 'readSymbolicLink', [pathOf(target)]);
+            return String(bridge.callInstance(resolved, 'toString', []));
+        },
+        symlink(target, linkPath) {
+            bridge.callStatic('java.nio.file.Files', 'createSymbolicLink', [pathOf(linkPath), pathOf(target)]);
+        },
+        chmod(target, mode) {
+            callFile(target, 'setReadable', [(mode & 0o444) !== 0, false]);
+            callFile(target, 'setWritable', [(mode & 0o222) !== 0, false]);
+            callFile(target, 'setExecutable', [(mode & 0o111) !== 0, false]);
+        },
+        truncate(target, length) {
+            const handle = bridge.newInstance('java.io.RandomAccessFile', [target, 'rw']);
+            try {
+                bridge.callInstance(handle, 'setLength', [length]);
+            }
+            finally {
+                bridge.callInstance(handle, 'close', []);
+            }
+        },
+        utimes(target, atimeMs, mtimeMs) {
+            const ok = bridge.normalizeBoolean(callFile(target, 'setLastModified', [mtimeMs]));
+            if (!ok) {
+                throw (0, errors_1.javaError)('java.io.IOException: Cannot set times on ' + target);
+            }
+        },
+        mkdtemp(prefix) {
+            for (let attempt = 0; attempt < 64; attempt += 1) {
+                const candidate = prefix + randomSuffix();
+                if (!bridge.normalizeBoolean(callFile(candidate, 'exists'))) {
+                    if (bridge.normalizeBoolean(callFile(candidate, 'mkdir'))) {
+                        return candidate;
+                    }
+                }
+            }
+            throw (0, errors_1.javaError)('java.io.IOException: Cannot create temp directory under ' + prefix);
+        }
+    };
+}
+const SUFFIX_ALPHABET = 'abcdefghijklmnopqrstuvwxyz0123456789';
+function randomSuffix() {
+    let out = '';
+    for (let i = 0; i < 6; i += 1) {
+        out += SUFFIX_ALPHABET.charAt(Math.floor(Math.random() * SUFFIX_ALPHABET.length));
+    }
+    return out;
+}

package/dist/lib/fs-env.d.ts

@@ -0,0 +1,30 @@
+export interface FsEnvironmentSpec {
+    readonly name: string;
+    /** 物理根。用函数是为了让 config / app 这类根惰性解析（需要 bridge）。 */
+    readonly root: string | (() => string);
+    readonly writable: boolean;
+}
+export interface FsEnvHooks {
+    setCwd(path: string): void;
+    getCwd(): string;
+    /** 探测根是否可用；抛错即视为不可用。 */
+    probe(root: string): void;
+}
+export declare function setHooks(next: FsEnvHooks): void;
+/** 注册自定义环境。内置环境名不可覆盖。 */
+export declare function define(name: string, spec: Omit<FsEnvironmentSpec, 'name'>): void;
+export declare function names(): string[];
+export declare function current(): string | null;
+export declare function root(): string;
+export declare function writable(): boolean;
+/** 显式切换环境。根不可用即拒绝，不做任何降级。 */
+export declare function use(name: string): void;
+/** 作用域内切换，回调必须同步返回。 */
+export declare function withEnvironment<T>(name: string, callback: () => T): T;
+/** 回到 UNBOUND。cwd 不动 —— 调用方要回默认值请再 use('sdcard')。 */
+export declare function reset(): void;
+/** strict 模式下，未显式 use() 就使用 fs 会直接报错。 */
+export declare function strict(flag: boolean): void;
+export declare function isStrict(): boolean;
+/** fs 每次操作前调用：非 strict 时按默认环境惰性绑定。 */
+export declare function ensureBound(): void;

package/dist/lib/fs-env.js

@@ -0,0 +1,157 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setHooks = setHooks;
+exports.define = define;
+exports.names = names;
+exports.current = current;
+exports.root = root;
+exports.writable = writable;
+exports.use = use;
+exports.withEnvironment = withEnvironment;
+exports.reset = reset;
+exports.strict = strict;
+exports.isStrict = isStrict;
+exports.ensureBound = ensureBound;
+/**
+ * fs 的环境状态机。
+ *
+ * 模型：环境 = 根 + 能力。切环境就是切 cwd —— 相对路径与 path.resolve 的基准随之改变，
+ * 所以状态机不是给 fs 打的补丁，而是路径语义的唯一来源。
+ *
+ *     UNBOUND ──首次使用──▶ BOUND(sdcard)
+ *     BOUND(A) ──use(B)──▶ BOUND(B)
+ *     BOUND(A) ──with(B, fn)──▶ BOUND(B) ──fn 同步返回──▶ BOUND(A)
+ *     BOUND(*) ──reset()──▶ UNBOUND
+ *
+ * 为什么 with() 强制同步：模块实例会跨工具调用复用（见 DESIGN.md §7.4），
+ * 一旦回调是异步的，await 期间别的代码就会看到被改掉的环境。
+ */
+const errors_1 = require("./errors");
+const paths_1 = require("./paths");
+const BUILTIN_ENVS = [
+    { name: 'sdcard', root: '/sdcard', writable: true },
+    { name: 'config', root: () => (0, paths_1.pluginConfigDir)(), writable: true },
+    { name: 'app', root: () => (0, paths_1.filesDir)(), writable: true }
+];
+const BUILTIN_NAMES = BUILTIN_ENVS.map((item) => item.name);
+const specs = new Map();
+BUILTIN_ENVS.forEach((item) => specs.set(item.name, item));
+let hooks = null;
+let currentName = null;
+let strictMode = false;
+const stack = [];
+function setHooks(next) {
+    hooks = next;
+}
+function requireHooks() {
+    if (hooks === null) {
+        throw (0, errors_1.onjError)('ONJ_MISSING_HOST', 'fs 环境状态机尚未接入宿主。');
+    }
+    return hooks;
+}
+function resolveRoot(spec) {
+    const value = typeof spec.root === 'function' ? spec.root() : spec.root;
+    if (typeof value !== 'string' || value.length === 0) {
+        throw (0, errors_1.onjError)('ONJ_ENV_UNAVAILABLE', '环境 ' + spec.name + ' 的根解析为空。');
+    }
+    return value;
+}
+/** 注册自定义环境。内置环境名不可覆盖。 */
+function define(name, spec) {
+    if (typeof name !== 'string' || name.trim().length === 0) {
+        throw new TypeError('fs.env.define 的名称必须是非空字符串。');
+    }
+    if (BUILTIN_NAMES.indexOf(name) >= 0) {
+        throw (0, errors_1.onjError)('ONJ_UNKNOWN_ENV', '内置环境 ' + name + ' 不可覆盖。');
+    }
+    if (spec === null || typeof spec !== 'object') {
+        throw new TypeError('fs.env.define 的 spec 必须是对象。');
+    }
+    specs.set(name, { name: name, root: spec.root, writable: spec.writable !== false });
+}
+function names() {
+    return Array.from(specs.keys());
+}
+function current() {
+    return currentName;
+}
+function root() {
+    const spec = requireCurrent();
+    return resolveRoot(spec);
+}
+function writable() {
+    return requireCurrent().writable;
+}
+function requireCurrent() {
+    if (currentName === null) {
+        throw (0, errors_1.onjError)('ONJ_ENV_NOT_SET');
+    }
+    const spec = specs.get(currentName);
+    if (spec === undefined) {
+        throw (0, errors_1.onjError)('ONJ_UNKNOWN_ENV', currentName);
+    }
+    return spec;
+}
+/** 显式切换环境。根不可用即拒绝，不做任何降级。 */
+function use(name) {
+    const spec = specs.get(name);
+    if (spec === undefined) {
+        throw (0, errors_1.onjError)('ONJ_UNKNOWN_ENV', name);
+    }
+    const target = resolveRoot(spec);
+    const host = requireHooks();
+    try {
+        host.probe(target);
+    }
+    catch (failure) {
+        throw (0, errors_1.onjError)('ONJ_ENV_UNAVAILABLE', '环境 ' + name + ' 的根 ' + target + ' 不可用。');
+    }
+    host.setCwd(target);
+    currentName = name;
+}
+/** 作用域内切换，回调必须同步返回。 */
+function withEnvironment(name, callback) {
+    const host = requireHooks();
+    const previousName = currentName;
+    const previousCwd = host.getCwd();
+    use(name);
+    try {
+        const result = callback();
+        if (isThenable(result)) {
+            throw (0, errors_1.onjError)('ONJ_ENV_ASYNC_SCOPE');
+        }
+        return result;
+    }
+    finally {
+        host.setCwd(previousCwd);
+        currentName = previousName;
+    }
+}
+/** 回到 UNBOUND。cwd 不动 —— 调用方要回默认值请再 use('sdcard')。 */
+function reset() {
+    currentName = null;
+    stack.length = 0;
+}
+/** strict 模式下，未显式 use() 就使用 fs 会直接报错。 */
+function strict(flag) {
+    strictMode = flag === true;
+}
+function isStrict() {
+    return strictMode;
+}
+/** fs 每次操作前调用：非 strict 时按默认环境惰性绑定。 */
+function ensureBound() {
+    if (currentName !== null) {
+        return;
+    }
+    if (strictMode) {
+        throw (0, errors_1.onjError)('ONJ_ENV_NOT_SET');
+    }
+    use(BUILTIN_NAMES[0]);
+}
+function isThenable(value) {
+    if (value === null || typeof value !== 'object') {
+        return false;
+    }
+    return typeof value.then === 'function';
+}

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

@@ -0,0 +1,19 @@
+/**
+ * fs 的公开类型。
+ *
+ * 独立成文件的原因与 path-types / zlib-types / stream-types 相同：
+ * fs.ts 用 `export =` 导出模块本体，无法再导出类型，而 index.ts 聚合时
+ * 要求这些名字是"可命名"的。
+ */
+export interface ReadStreamOptions {
+    flags?: string;
+    encoding?: string;
+    start?: number;
+    end?: number;
+    highWaterMark?: number;
+}
+export interface WriteStreamOptions {
+    flags?: string;
+    encoding?: string;
+    highWaterMark?: number;
+}

package/dist/lib/fs-types.js

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

package/dist/lib/hashes.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 纯 JS 的哈希原语（md5 / sha1 / sha224 / sha256 / sha384 / sha512）。
+ *
+ * 为什么自己实现而不是借运行时：
+ *   Operit 注入的全局 CryptoJS 只是个 4KB 的 shim，只有 MD5(string) 和 AES.decrypt；
+ *   NativeInterface.crypto 也只认 md5 与 aes/decrypt。都不足以支撑 crypto 模块。
+ *
+ * 实现取舍：
+ *   32 位算法（md5/sha1/sha256）用标准 32 位算术；
+ *   sha384/sha512 用 BigInt 写 64 位轮 —— 代码短、不易错，代价是大输入的吞吐。
+ *   正确性由 test/crypto.test.js 与 Node 的 crypto 全量对拍保证。
+ */
+export interface HashSpec {
+    readonly name: string;
+    readonly blockSize: number;
+    readonly digestLength: number;
+    compute(bytes: Uint8Array): Uint8Array;
+}
+export declare const HASHES: Readonly<Record<string, HashSpec>>;
+/** 把 Node 的算法别名（大小写、连字符、sha-256 之类）归一到注册表的键。 */
+export declare function resolveAlgorithm(name: string): HashSpec;
+export declare function hashNames(): string[];
+/** HMAC（RFC 2104）。 */
+export declare function hmac(spec: HashSpec, key: Uint8Array, message: Uint8Array): Uint8Array;
+/** PBKDF2（RFC 2898），基于 HMAC。 */
+export declare function pbkdf2(spec: HashSpec, password: Uint8Array, salt: Uint8Array, iterations: number, keyLength: number): Uint8Array;
+export declare function toHex(bytes: Uint8Array): string;