@dangao/bun-server 2.2.0 → 3.0.0

package/docs/zh/platform.md

@@ -0,0 +1,299 @@
+# 平台适配指南
+
+[English](../platform.md) | **中文**
+
+---
+
+Bun Server 通过内部的 Platform Adapter Layer，原生支持在 **Bun** 和 **Node.js 22+** 上运行。所有运行时相关的 API（HTTP 服务器、文件 I/O、加密、解析器、进程管理、WebSocket）均被抽象到统一的 TypeScript 接口后。你编写一套代码，框架在启动时自动选择正确的实现——无需额外配置。
+
+## 目录
+
+- [架构](#架构)
+- [运行时检测](#运行时检测)
+- [平台配置](#平台配置)
+- [支持矩阵](#支持矩阵)
+- [数据库自动适配](#数据库自动适配)
+- [公开 API 变更](#公开-api-变更)
+- [Bun 独有特性](#bun-独有特性)
+- [Node.js 启动指南](#nodejs-启动指南)
+- [多运行时测试](#多运行时测试)
+- [已知限制](#已知限制)
+
+---
+
+## 架构
+
+```
+┌──────────────────────────────────────────────────────┐
+│                   应用层                              │
+│   Controllers / Services / Modules / Middleware       │
+└──────────────────────────┬───────────────────────────┘
+                           │ getRuntime()
+┌──────────────────────────▼───────────────────────────┐
+│              Platform Adapter Layer                   │
+│  IFsAdapter · ICryptoAdapter · IParserAdapter         │
+│  IProcessAdapter · IHttpDriver · IWebSocket           │
+└──────┬───────────────────────────────┬───────────────┘
+       │                               │
+┌──────▼──────┐                 ┌──────▼──────┐
+│ BunPlatform │                 │ NodePlatform│
+│ Bun.serve   │                 │ node:http   │
+│ Bun.file    │                 │ node:fs     │
+│ Bun.Crypto  │                 │ node:crypto │
+│ spawn(bun)  │                 │ ws package  │
+└─────────────┘                 └─────────────┘
+```
+
+每个适配器接口及其对应实现：
+
+| 接口 | Bun 实现 | Node.js 实现 |
+|---|---|---|
+| `IFsAdapter` | `Bun.file`、`Bun.write`、`Bun.Glob` | `node:fs/promises`、`node:fs` glob |
+| `ICryptoAdapter` | `Bun.CryptoHasher` | `node:crypto` HMAC/hash |
+| `IParserAdapter` | `Bun.JSONC`、`Bun.JSON5`、`Bun.JSONL`、`Bun.markdown` | `jsonc-parser`、`json5`、自定义 JSONL、`marked` |
+| `IProcessAdapter` | `spawn`（bun）、`Bun.sleep` | `node:child_process`、`setTimeout` |
+| `IHttpDriver` | `Bun.serve` | `node:http.createServer` |
+| `IWebSocket<T>` | `Bun.ServerWebSocket<T>` | `ws` 包 |
+
+---
+
+## 运行时检测
+
+平台在 `Application` 构造时按以下优先级链解析：
+
+```
+1. Bootstrap 配置  →  new Application({ platform: 'node' })
+2. CLI 参数        →  --platform=node
+3. 环境变量        →  BUN_SERVER_PLATFORM=node
+4. 自动检测        →  typeof Bun !== 'undefined' ? 'bun' : 'node'
+```
+
+一旦解析完成，单例在进程生命周期内保持不变。后续调用 `getRuntime()` 始终返回同一实例。
+
+---
+
+## 平台配置
+
+### 方式一 — 代码配置（最高优先级）
+
+```typescript
+import { Application } from '@dangao/bun-server';
+
+const app = new Application({ platform: 'node' }); // 'bun' | 'node'
+app.registerModule(AppModule);
+await app.listen(3000);
+```
+
+### 方式二 — CLI 参数
+
+```bash
+# Bun 运行时，但强制使用 Node.js 适配器
+bun run src/main.ts --platform=node
+
+# Node.js 运行时（无需参数，自动检测）
+node dist/main.js
+```
+
+### 方式三 — 环境变量
+
+```bash
+BUN_SERVER_PLATFORM=node node dist/main.js
+```
+
+### 方式四 — 自动检测（默认，无需配置）
+
+无需任何配置。如果 `typeof Bun !== 'undefined'`，选择 `BunPlatform`；否则自动选择 `NodePlatform`。
+
+---
+
+## 支持矩阵
+
+| 特性 | Bun | Node.js 22+ |
+|---|---|---|
+| HTTP 服务器 | `Bun.serve`（原生） | `node:http` |
+| WebSocket | `Bun.ServerWebSocket`（原生） | `ws` 包 |
+| 文件 I/O | `Bun.file / Bun.write` | `node:fs/promises` |
+| Crypto / JWT | `Bun.CryptoHasher` | `node:crypto` |
+| JSONC 解析 | `Bun.JSONC` | `jsonc-parser` 包 |
+| JSON5 解析 | `Bun.JSON5` | `json5` 包 |
+| JSONL 解析 | `Bun.JSONL` | 自定义流式解析器 |
+| Markdown 渲染 | `Bun.markdown` | `marked` 包 |
+| Cluster spawn | Bun `spawn` | `node:child_process` |
+| SQLite | `bun:sqlite` | `better-sqlite3` |
+| PostgreSQL | `Bun.SQL` | `postgres` 包 |
+| MySQL | `Bun.SQL` | `mysql2` 包 |
+| `idleTimeout` | 支持 | 静默忽略 |
+| `reusePort` | 支持 | 静默忽略 |
+| SSE TCP keepalive | 支持（via `server.timeout`） | 不可用 |
+| 整体性能 | 最优 | 良好 |
+
+---
+
+## 数据库自动适配
+
+`DatabaseModule` 根据检测到的平台自动选择数据库驱动，**无需用户额外配置**。
+
+```
+Bun 平台                          Node.js 平台
+─────────────────────────────    ─────────────────────────────
+SQLite  →  bun:sqlite            SQLite  →  better-sqlite3
+PostgreSQL  →  Bun.SQL           PostgreSQL  →  postgres 包
+MySQL  →  Bun.SQL                MySQL  →  mysql2 包
+```
+
+你的 `DatabaseModule` 配置在两个平台间完全一致：
+
+```typescript
+DatabaseModule.forRoot({
+  connections: [
+    {
+      name: 'default',
+      type: 'sqlite',
+      database: './data/app.db',
+    },
+    {
+      name: 'pg',
+      type: 'postgres',
+      url: process.env.DATABASE_URL,
+    },
+  ],
+})
+```
+
+---
+
+## 公开 API 变更
+
+### `BunServer.getServer()`
+
+返回 `IServerHandle | undefined`（原来为 `Bun.Server | undefined`）。
+
+```typescript
+const handle: IServerHandle | undefined = app.getServer();
+handle?.port;      // number
+handle?.hostname;  // string
+await handle?.stop();
+
+// 访问底层原生服务器实例（不推荐，类型为 unknown）
+const native: unknown = app.getNativeServer();
+// Bun:     native as Bun.Server<any>
+// Node.js: native as import('node:http').Server
+```
+
+### `WsArgumentsHost.getClient()`
+
+返回 `IWebSocket<T>` 而非 Bun 的 `ServerWebSocket<T>`。这是 WebSocket 公开 API 中的**唯一破坏性变更**。
+
+```typescript
+import type { IWebSocket } from '@dangao/bun-server';
+
+@WebSocketGateway()
+class ChatGateway {
+  @OnMessage('chat')
+  onChat(client: IWebSocket<unknown>, data: unknown) {
+    client.send('pong');
+  }
+}
+```
+
+`IWebSocket<T>` 暴露与 `ServerWebSocket<T>` 相同的核心方法：
+`send`、`close`、`data`、`readyState`、`remoteAddress`。
+
+---
+
+## Bun 独有特性
+
+以下选项在 `ApplicationOptions` 中接受，但仅在 Bun 上生效，在 Node.js 上静默忽略。
+
+| 选项 | Bun 效果 | Node.js |
+|---|---|---|
+| `idleTimeout` | 通过 `Bun.serve` 设置 TCP 空闲超时 | 忽略 |
+| `reusePort` | 通过 `Bun.serve` 启用端口复用 | 忽略 |
+| `sseKeepAlive` | 使用 `server.timeout(req, 0)` | 仅注入心跳 |
+
+如果你的应用依赖这些特性，请在文档中明确说明对 Bun 运行时的要求。
+
+---
+
+## Node.js 启动指南
+
+### 1. 安装
+
+```bash
+npm install @dangao/bun-server
+# Node.js 所需的对等依赖会自动安装
+```
+
+### 2. 构建
+
+```bash
+# 使用 bun build 输出面向 Node.js 的 JS 文件
+bun build src/main.ts --target=node --outdir=dist
+
+# 或使用 tsc
+npx tsc
+```
+
+### 3. 运行
+
+```bash
+node dist/main.js
+# 平台自动检测为 'node'，无需额外参数
+```
+
+### 4. 冒烟测试（验证 bun build 输出能被 Node.js 原生运行）
+
+```bash
+bun run test:node
+# 等价于：vitest run tests/platform/node
+```
+
+---
+
+## 多运行时测试
+
+共享测试用例位于 `tests/platform/shared/*.cases.ts`。Bun 和 Node.js 的测试运行器导入相同的断言，保证测试覆盖完全一致。
+
+```
+tests/platform/
+├── shared/
+│   ├── suite.ts              ← TestSuite 接口（test / expect / beforeEach）
+│   ├── fs.cases.ts
+│   ├── crypto.cases.ts
+│   ├── parser.cases.ts
+│   ├── process.cases.ts
+│   ├── websocket.cases.ts
+│   └── database.cases.ts
+├── bun/                      ← bun:test 运行器
+│   └── *.test.ts
+├── node/                     ← vitest 运行器
+│   ├── *.test.ts
+│   └── build-smoke.test.ts   ← 验证 bun build --target=node 输出
+└── detector.test.ts          ← 优先级链单元测试
+```
+
+### 执行测试
+
+```bash
+# Bun 平台测试
+bun run test:bun
+
+# Node.js 平台测试
+bun run test:node
+
+# 两个平台全部测试
+bun run test:platform
+```
+
+---
+
+## 已知限制
+
+| 限制 | 说明 |
+|---|---|
+| `idleTimeout` / `reusePort` | Bun 独有，Node.js 无对等实现 |
+| SSE TCP keepalive（`server.timeout`） | Bun 独有 API；Node.js 仅支持心跳注入 |
+| `Bun.SQL` 高级特性 | 部分 Bun.SQL 选项（如预处理语句缓存）在 `postgres`/`mysql2` 中不可用 |
+| Node.js 上的 Cluster 模式 | 使用 `node:child_process`，行为可能与 Bun cluster 存在差异 |
+| `bun:sqlite` 扩展 | Bun SQLite 支持扩展加载；`better-sqlite3` 的扩展机制不同 |
+| 整体性能 | Bun 原生 API 在文件 I/O 和加密等方面性能优于 Node.js 适配实现 |

package/docs/zh/testing.md

@@ -61,6 +61,66 @@ const client = await module.createHttpClient();
 
 `options` 支持 `headers`、`body`、`query`。响应对象包含 `status`、`headers`、`body`、`text`、`ok`。
 
+## 多运行时测试
+
+框架内置的共享测试策略，能在 Bun 和 Node.js 上运行完全相同的测试用例。
+
+### 测试目录结构
+
+```
+tests/platform/
+├── shared/          ← 平台无关的断言辅助函数
+│   ├── suite.ts     ← TestSuite 接口（test / expect / beforeEach）
+│   ├── fs.cases.ts
+│   ├── crypto.cases.ts
+│   ├── parser.cases.ts
+│   ├── process.cases.ts
+│   ├── websocket.cases.ts
+│   └── database.cases.ts
+├── bun/             ← bun:test 运行器（initRuntime('bun')）
+│   └── *.test.ts
+└── node/            ← vitest 运行器（initRuntime('node')）
+    ├── *.test.ts
+    └── build-smoke.test.ts
+```
+
+### 执行平台测试
+
+```bash
+# 仅 Bun 平台测试
+bun run test:bun
+
+# 仅 Node.js 平台测试（使用 vitest）
+bun run test:node
+
+# 两个平台全部测试
+bun run test:platform
+```
+
+### 编写跨平台测试
+
+在测试文件开头调用 `initRuntime()`：
+
+```ts
+// tests/platform/bun/fs.test.ts
+import { test, expect, beforeEach } from 'bun:test';
+import { initRuntime, _resetRuntime } from '../../../src/platform/runtime';
+import { runFsCases } from '../shared/fs.cases';
+
+initRuntime('bun');
+runFsCases({ test, expect, beforeEach });
+```
+
+```ts
+// tests/platform/node/fs.test.ts
+import { test, expect, beforeEach } from 'vitest';
+import { initRuntime, _resetRuntime } from '../../../src/platform/runtime';
+import { runFsCases } from '../shared/fs.cases';
+
+beforeEach(() => { _resetRuntime(); initRuntime('node'); });
+runFsCases({ test, expect, beforeEach });
+```
+
 ## 配合 bun:test 使用
 
 ```ts

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@dangao/bun-server",
-  "version": "2.2.0",
+  "version": "3.0.0",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
+      "node": "./dist/index.node.mjs",
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
       "default": "./dist/index.js"
@@ -38,27 +39,44 @@
     "url": "https://github.com/dangaogit/bun-server/issues"
   },
   "engines": {
-    "bun": ">=1.3.10"
+    "bun": ">=1.3.10",
+    "node": ">=22.0.0"
   },
   "scripts": {
     "dev": "bun --watch src/index.ts",
     "test": "bun test",
+    "test:bun": "bun test tests/platform/bun",
+    "test:node": "vitest run tests/platform/node",
+    "test:platform": "bun run test:bun && bun run test:node",
     "type-check": "tsc --noEmit",
     "clean": "rm -rf dist",
     "bundle": "bun build src/index.ts --target=bun --format=esm --outfile=dist/index.js --external reflect-metadata --external @dangao/logsmith --external @dangao/nacos-client",
+    "bundle:node": "bun build src/index.ts --target=node --packages=external --outfile=dist/index.node.mjs",
     "dts": "tsc -p tsconfig.build.json",
-    "build": "bun run clean && bun run bundle && bun run dts",
+    "build": "bun run clean && bun run bundle && bun run bundle:node && bun run dts",
     "prepublishOnly": "bun run build",
     "publish:package": "cp -r ../../README.md ../../LICENSE ../../docs . && bun publish --access public && rm -rf ./README.md ./LICENSE ./docs",
     "publish:package:github": "cp -r ../../README.md ../../LICENSE ../../docs . && bun pm pack --access public && npm publish *.tgz --provenance --access public && rm -rf ./README.md ./LICENSE ./docs"
   },
   "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/bun": "^1.3.10",
+    "@types/mime-types": "^3.0.1",
+    "@types/ws": "^8.18.1",
     "typescript": "^5.9.3",
-    "@types/bun": "^1.3.10"
+    "vitest": "^4.1.4"
   },
   "dependencies": {
-    "reflect-metadata": "^0.2.2",
     "@dangao/logsmith": "0.2.0",
-    "@dangao/nacos-client": "0.1.1"
+    "@dangao/nacos-client": "0.1.1",
+    "better-sqlite3": "^12.8.0",
+    "json5": "^2.2.3",
+    "jsonc-parser": "^3.3.1",
+    "marked": "^18.0.0",
+    "mime-types": "^3.0.2",
+    "mysql2": "^3.21.0",
+    "postgres": "^3.4.9",
+    "reflect-metadata": "^0.2.2",
+    "ws": "^8.20.0"
   }
 }

package/src/ai/providers/anthropic-provider.ts

@@ -56,7 +56,7 @@ export class AnthropicProvider implements LlmProvider {
       }));
     }
 
-    const response = await this.post('/v1/messages', body);
+    const response = await this.post('/v1/messages', body, request.signal);
     const usage = (response['usage'] as { input_tokens: number; output_tokens: number }) ?? { input_tokens: 0, output_tokens: 0 };
 
     let content = '';
@@ -108,6 +108,7 @@ export class AnthropicProvider implements LlmProvider {
     const baseUrl = this.baseUrl;
     const anthropicVersion = this.anthropicVersion;
     const encoder = new TextEncoder();
+    const signal = request.signal;
 
     return new ReadableStream<Uint8Array>({
       async start(controller) {
@@ -120,6 +121,7 @@ export class AnthropicProvider implements LlmProvider {
               'anthropic-version': anthropicVersion,
             },
             body: JSON.stringify(body),
+            signal,
           });
 
           if (!res.ok || !res.body) {
@@ -170,7 +172,7 @@ export class AnthropicProvider implements LlmProvider {
     return Math.ceil(messages.reduce((sum, m) => sum + m.content.length, 0) / 4);
   }
 
-  private async post(path: string, body: Record<string, unknown>): Promise<Record<string, unknown>> {
+  private async post(path: string, body: Record<string, unknown>, signal?: AbortSignal): Promise<Record<string, unknown>> {
     const res = await fetch(`${this.baseUrl}${path}`, {
       method: 'POST',
       headers: {
@@ -179,6 +181,7 @@ export class AnthropicProvider implements LlmProvider {
         'anthropic-version': this.anthropicVersion,
       },
       body: JSON.stringify(body),
+      signal,
     });
 
     if (res.status === 429) throw new AiRateLimitError(this.name);

package/src/ai/providers/google-provider.ts

@@ -50,6 +50,7 @@ export class GoogleProvider implements LlmProvider {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify(body),
+        signal: request.signal,
       },
     );
 
@@ -95,6 +96,7 @@ export class GoogleProvider implements LlmProvider {
     const apiKey = this.apiKey;
     const baseUrl = this.baseUrl;
     const encoder = new TextEncoder();
+    const signal = request.signal;
 
     const body: Record<string, unknown> = {
       contents,
@@ -111,6 +113,7 @@ export class GoogleProvider implements LlmProvider {
               method: 'POST',
               headers: { 'Content-Type': 'application/json' },
               body: JSON.stringify(body),
+              signal,
             },
           );
 

package/src/ai/providers/ollama-provider.ts

@@ -33,6 +33,7 @@ export class OllamaProvider implements LlmProvider {
           num_predict: request.maxTokens,
         },
       }),
+      signal: request.signal,
     });
 
     if (!res.ok) {
@@ -61,6 +62,7 @@ export class OllamaProvider implements LlmProvider {
     const model = request.model ?? this.defaultModel;
     const baseUrl = this.baseUrl;
     const encoder = new TextEncoder();
+    const signal = request.signal;
 
     return new ReadableStream<Uint8Array>({
       async start(controller) {
@@ -77,6 +79,7 @@ export class OllamaProvider implements LlmProvider {
                 num_predict: request.maxTokens,
               },
             }),
+            signal,
           });
 
           if (!res.ok || !res.body) {

package/src/ai/providers/openai-provider.ts

@@ -79,7 +79,7 @@ export class OpenAIProvider implements LlmProvider {
       }));
     }
 
-    const response = await this.post('/chat/completions', body);
+    const response = await this.post('/chat/completions', body, request.signal);
     const choice = response.choices?.[0];
     const usage = response.usage ?? { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 };
     const message = choice?.message;
@@ -127,6 +127,7 @@ export class OpenAIProvider implements LlmProvider {
     const encoder = new TextEncoder();
     const apiKey = this.apiKey;
     const baseUrl = this.baseUrl;
+    const signal = request.signal;
 
     return new ReadableStream<Uint8Array>({
       async start(controller) {
@@ -138,6 +139,7 @@ export class OpenAIProvider implements LlmProvider {
               'Authorization': `Bearer ${apiKey}`,
             },
             body: JSON.stringify(body),
+            signal,
           });
 
           if (!res.ok || !res.body) {
@@ -191,7 +193,7 @@ export class OpenAIProvider implements LlmProvider {
     return Math.ceil(messages.reduce((sum, m) => sum + m.content.length, 0) / 4);
   }
 
-  private async post(path: string, body: Record<string, unknown>): Promise<OpenAiChatCompletionResponse> {
+  private async post(path: string, body: Record<string, unknown>, signal?: AbortSignal): Promise<OpenAiChatCompletionResponse> {
     const res = await fetch(`${this.baseUrl}${path}`, {
       method: 'POST',
       headers: {
@@ -199,6 +201,7 @@ export class OpenAIProvider implements LlmProvider {
         'Authorization': `Bearer ${this.apiKey}`,
       },
       body: JSON.stringify(body),
+      signal,
     });
 
     if (res.status === 429) {

package/src/ai/service.ts

@@ -120,7 +120,7 @@ export class AiService {
     const timeout = this.options.timeout ?? 30000;
 
     if (!fallback) {
-      return this.withTimeout(this.getProvider(targetName).complete(request), timeout, targetName);
+      return this.withTimeout(this.getProvider(targetName).complete(request), timeout, targetName, request.signal);
     }
 
     // Fallback chain: try target first, then others in order
@@ -134,7 +134,7 @@ export class AiService {
       try {
         const provider = this.providers.get(name);
         if (!provider) continue;
-        return await this.withTimeout(provider.complete({ ...request, provider: name }), timeout, name);
+        return await this.withTimeout(provider.complete({ ...request, provider: name }), timeout, name, request.signal);
       } catch (err) {
         errors.push(`${name}: ${err instanceof Error ? err.message : String(err)}`);
       }
@@ -143,12 +143,24 @@ export class AiService {
     throw new AiAllProvidersFailed(errors);
   }
 
-  private withTimeout<T>(promise: Promise<T>, ms: number, providerName: string): Promise<T> {
+  private withTimeout<T>(promise: Promise<T>, ms: number, providerName: string, signal?: AbortSignal): Promise<T> {
     return new Promise<T>((resolve, reject) => {
+      if (signal?.aborted) {
+        reject(signal.reason ?? new Error('Aborted'));
+        return;
+      }
+
       const timer = setTimeout(() => reject(new AiTimeoutError(providerName, ms)), ms);
+
+      const onAbort = () => {
+        clearTimeout(timer);
+        reject(signal!.reason ?? new Error('Aborted'));
+      };
+      signal?.addEventListener('abort', onAbort, { once: true });
+
       promise.then(
-        (val) => { clearTimeout(timer); resolve(val); },
-        (err) => { clearTimeout(timer); reject(err); },
+        (val) => { clearTimeout(timer); signal?.removeEventListener('abort', onAbort); resolve(val); },
+        (err) => { clearTimeout(timer); signal?.removeEventListener('abort', onAbort); reject(err); },
       );
     });
   }

package/src/ai/types.ts

@@ -45,6 +45,11 @@ export interface AiRequest {
   tools?: AiToolDefinition[];
   /** Provider name override */
   provider?: string;
+  /**
+   * Abort signal — pass `ctx.signal` to cascade client disconnection
+   * to the upstream AI API, stopping token consumption immediately.
+   */
+  signal?: AbortSignal;
 }
 
 /**

package/src/auth/jwt.ts

@@ -1,4 +1,5 @@
 import type { JWTConfig, JWTPayload } from './types';
+import { getRuntime } from '../platform/runtime';
 
 /**
  * JWT 工具类
@@ -120,7 +121,7 @@ export class JWTUtil {
 
     if (key.length > blockSize) {
       // 如果密钥长度超过块大小，先哈希
-      const hasher = new Bun.CryptoHasher('sha256');
+      const hasher = getRuntime().crypto.createHasher('sha256');
       hasher.update(key);
       keyBuffer = new Uint8Array(hasher.digest());
     } else {
@@ -141,7 +142,7 @@ export class JWTUtil {
     const innerData = new Uint8Array(iKeyPad.length + data.length);
     innerData.set(iKeyPad);
     innerData.set(data, iKeyPad.length);
-    const innerHasher = new Bun.CryptoHasher('sha256');
+    const innerHasher = getRuntime().crypto.createHasher('sha256');
     innerHasher.update(innerData);
     const innerHash = new Uint8Array(innerHasher.digest());
 
@@ -149,7 +150,7 @@ export class JWTUtil {
     const outerData = new Uint8Array(oKeyPad.length + innerHash.length);
     outerData.set(oKeyPad);
     outerData.set(innerHash, oKeyPad.length);
-    const outerHasher = new Bun.CryptoHasher('sha256');
+    const outerHasher = getRuntime().crypto.createHasher('sha256');
     outerHasher.update(outerData);
 
     return new Uint8Array(outerHasher.digest());