@openclaw-china/shared 0.1.28 → 0.1.30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw-china/shared",
-  "version": "0.1.28",
+  "version": "0.1.30",
   "type": "module",
   "exports": {
     ".": "./src/index.ts"

package/src/asr/README.md

@@ -0,0 +1,100 @@
+# ASR 接入说明（供各插件复用）
+
+本文说明如何在任意渠道插件中复用 `@openclaw-china/shared` 的语音转文本能力。
+
+当前已提供：
+- 腾讯云录音文件识别极速版（`asr/flash/v1`）
+- 统一错误类型（便于插件侧日志和降级）
+
+## 职责边界
+
+`shared` 负责：
+- 调用 ASR 服务（签名、请求、响应解析、超时）
+- 抛出结构化错误（`ASRError` 及子类）
+
+单个插件负责：
+- 平台事件解析（如何识别语音消息）
+- 媒体下载（URL/鉴权/大小限制）
+- 业务策略（失败是否降级、回复文案、是否中断本次处理）
+- 密钥配置（建议保留在插件配置内）
+
+## 可直接使用的导出
+
+```ts
+import {
+  transcribeTencentFlash,
+  ASRError,
+  ASRTimeoutError,
+  ASRAuthError,
+  ASRRequestError,
+  ASRResponseParseError,
+  ASRServiceError,
+  ASREmptyResultError,
+} from "@openclaw-china/shared";
+```
+
+## 插件接入步骤
+
+1. 在插件配置中增加 ASR 字段（示例）
+```ts
+asr: {
+  enabled?: boolean;
+  appId?: string;
+  secretId?: string;
+  secretKey?: string;
+}
+```
+
+2. 在入站消息里识别语音附件，并下载到 `Buffer`
+- 推荐复用 `shared/media` 的下载能力：
+```ts
+import { fetchMediaFromUrl } from "@openclaw-china/shared";
+```
+
+3. 调用转写
+```ts
+const transcript = await transcribeTencentFlash({
+  audio: media.buffer,
+  config: {
+    appId: asr.appId,
+    secretId: asr.secretId,
+    secretKey: asr.secretKey,
+    // 可选，默认如下：
+    // engineType: "16k_zh",
+    // voiceFormat: "silk",
+    // timeoutMs: 30000,
+  },
+});
+```
+
+4. 按错误类型做日志与降级
+```ts
+try {
+  // transcribeTencentFlash(...)
+} catch (err) {
+  if (err instanceof ASRError) {
+    logger.warn(
+      `asr failed kind=${err.kind} provider=${err.provider} retryable=${err.retryable} msg=${err.message}`
+    );
+  } else {
+    logger.warn(`asr failed: ${String(err)}`);
+  }
+  // 在这里决定是否回退文本、提示用户、或继续其他链路
+}
+```
+
+## 错误类型语义
+
+- `ASRTimeoutError`：请求超时，通常可重试
+- `ASRAuthError`：鉴权失败（密钥错误/权限问题），通常不可重试
+- `ASRRequestError`：请求失败（网络或 HTTP 失败）
+- `ASRResponseParseError`：服务返回非 JSON 或格式异常
+- `ASRServiceError`：服务端返回业务错误码（`code != 0`）
+- `ASREmptyResultError`：识别成功但无文本
+
+## 最佳实践
+
+- 不要把密钥硬编码到仓库；仅通过配置注入。
+- 给下载和 ASR 都设置超时与大小上限。
+- 将“ASR 失败文案”放在插件侧，不放到 `shared`。
+- 先记录结构化日志，再决定业务降级策略。

package/src/asr/errors.ts

@@ -0,0 +1,61 @@
+export type ASRErrorKind =
+  | "timeout"
+  | "auth"
+  | "request"
+  | "response_parse"
+  | "service"
+  | "empty_result";
+
+export class ASRError extends Error {
+  constructor(
+    message: string,
+    public readonly kind: ASRErrorKind,
+    public readonly provider: string,
+    public readonly retryable: boolean = false
+  ) {
+    super(message);
+    this.name = "ASRError";
+  }
+}
+
+export class ASRTimeoutError extends ASRError {
+  constructor(provider: string, public readonly timeoutMs: number) {
+    super(`ASR request timeout after ${timeoutMs}ms`, "timeout", provider, true);
+    this.name = "ASRTimeoutError";
+  }
+}
+
+export class ASRAuthError extends ASRError {
+  constructor(provider: string, message: string, public readonly status?: number) {
+    super(message, "auth", provider, false);
+    this.name = "ASRAuthError";
+  }
+}
+
+export class ASRRequestError extends ASRError {
+  constructor(provider: string, message: string, public readonly status?: number) {
+    super(message, "request", provider, true);
+    this.name = "ASRRequestError";
+  }
+}
+
+export class ASRResponseParseError extends ASRError {
+  constructor(provider: string, public readonly bodySnippet: string) {
+    super("ASR response is not valid JSON", "response_parse", provider, false);
+    this.name = "ASRResponseParseError";
+  }
+}
+
+export class ASRServiceError extends ASRError {
+  constructor(provider: string, message: string, public readonly serviceCode?: number) {
+    super(message, "service", provider, false);
+    this.name = "ASRServiceError";
+  }
+}
+
+export class ASREmptyResultError extends ASRError {
+  constructor(provider: string) {
+    super("ASR returned empty transcript", "empty_result", provider, false);
+    this.name = "ASREmptyResultError";
+  }
+}

package/src/asr/index.ts

@@ -0,0 +1,11 @@
+export { transcribeTencentFlash, type TencentFlashASRConfig } from "./tencent-flash.js";
+export {
+  ASRError,
+  ASRTimeoutError,
+  ASRAuthError,
+  ASRRequestError,
+  ASRResponseParseError,
+  ASRServiceError,
+  ASREmptyResultError,
+  type ASRErrorKind,
+} from "./errors.js";

package/src/asr/tencent-flash.ts

@@ -0,0 +1,165 @@
+import { createHmac } from "node:crypto";
+import {
+  ASRAuthError,
+  ASREmptyResultError,
+  ASRRequestError,
+  ASRResponseParseError,
+  ASRServiceError,
+  ASRTimeoutError,
+} from "./errors.js";
+
+const ASR_FLASH_HOST = "asr.cloud.tencent.com";
+const ASR_FLASH_PATH_PREFIX = "/asr/flash/v1";
+const ASR_FLASH_URL_PREFIX = `https://${ASR_FLASH_HOST}${ASR_FLASH_PATH_PREFIX}`;
+const ASR_PROVIDER = "tencent-flash";
+
+export interface TencentFlashASRConfig {
+  appId: string;
+  secretId: string;
+  secretKey: string;
+  engineType?: string;
+  voiceFormat?: string;
+  timeoutMs?: number;
+}
+
+interface TencentFlashResponseSentence {
+  text?: string;
+}
+
+interface TencentFlashResponseItem {
+  text?: string;
+  sentence_list?: TencentFlashResponseSentence[];
+}
+
+interface TencentFlashResponse {
+  code?: number;
+  message?: string;
+  flash_result?: TencentFlashResponseItem[];
+}
+
+function encodeQueryValue(value: string): string {
+  return encodeURIComponent(value)
+    .replace(/%20/g, "+")
+    .replace(/[!'()*]/g, (char) => `%${char.charCodeAt(0).toString(16).toUpperCase()}`);
+}
+
+function buildSignedQuery(params: Record<string, string>): string {
+  return Object.entries(params)
+    .sort(([a], [b]) => a.localeCompare(b))
+    .map(([key, value]) => `${encodeURIComponent(key)}=${encodeQueryValue(value)}`)
+    .join("&");
+}
+
+function extractTranscript(payload: TencentFlashResponse): string {
+  const items = Array.isArray(payload.flash_result) ? payload.flash_result : [];
+  const lines: string[] = [];
+
+  for (const item of items) {
+    if (typeof item?.text === "string" && item.text.trim()) {
+      lines.push(item.text.trim());
+      continue;
+    }
+    const sentenceList = Array.isArray(item?.sentence_list) ? item.sentence_list : [];
+    for (const sentence of sentenceList) {
+      if (typeof sentence?.text === "string" && sentence.text.trim()) {
+        lines.push(sentence.text.trim());
+      }
+    }
+  }
+
+  return lines.join("\n").trim();
+}
+
+export async function transcribeTencentFlash(params: {
+  audio: Buffer;
+  config: TencentFlashASRConfig;
+}): Promise<string> {
+  const { audio, config } = params;
+  const timestamp = Math.floor(Date.now() / 1000).toString();
+  const engineType = config.engineType ?? "16k_zh";
+  const voiceFormat = config.voiceFormat ?? "silk";
+  const query = buildSignedQuery({
+    engine_type: engineType,
+    secretid: config.secretId,
+    timestamp,
+    voice_format: voiceFormat,
+  });
+
+  const signText = `POST${ASR_FLASH_HOST}${ASR_FLASH_PATH_PREFIX}/${config.appId}?${query}`;
+  const authorization = createHmac("sha1", config.secretKey).update(signText).digest("base64");
+  const url = `${ASR_FLASH_URL_PREFIX}/${config.appId}?${query}`;
+  const timeoutMs = config.timeoutMs ?? 30000;
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        Authorization: authorization,
+        "Content-Type": "application/octet-stream",
+      },
+      body: audio,
+      signal: controller.signal,
+    });
+
+    const bodyText = await response.text();
+    let payload: TencentFlashResponse;
+    try {
+      payload = JSON.parse(bodyText) as TencentFlashResponse;
+    } catch {
+      throw new ASRResponseParseError(ASR_PROVIDER, bodyText.slice(0, 300));
+    }
+
+    if (!response.ok) {
+      const message = payload.message ?? `HTTP ${response.status}`;
+      if (response.status === 401 || response.status === 403) {
+        throw new ASRAuthError(
+          ASR_PROVIDER,
+          `Tencent Flash ASR authentication failed: ${message}`,
+          response.status
+        );
+      }
+      throw new ASRRequestError(
+        ASR_PROVIDER,
+        `Tencent Flash ASR request failed: ${message}`,
+        response.status
+      );
+    }
+
+    if (payload.code !== 0) {
+      throw new ASRServiceError(
+        ASR_PROVIDER,
+        `Tencent Flash ASR failed: ${payload.message ?? "unknown error"} (code=${payload.code})`
+        ,
+        payload.code
+      );
+    }
+
+    const transcript = extractTranscript(payload);
+    if (!transcript) {
+      throw new ASREmptyResultError(ASR_PROVIDER);
+    }
+    return transcript;
+  } catch (error) {
+    if (error instanceof Error && error.name === "AbortError") {
+      throw new ASRTimeoutError(ASR_PROVIDER, timeoutMs);
+    }
+    if (
+      error instanceof ASRResponseParseError ||
+      error instanceof ASRAuthError ||
+      error instanceof ASRRequestError ||
+      error instanceof ASRServiceError ||
+      error instanceof ASREmptyResultError ||
+      error instanceof ASRTimeoutError
+    ) {
+      throw error;
+    }
+    throw new ASRRequestError(
+      ASR_PROVIDER,
+      `Tencent Flash ASR request failed: ${error instanceof Error ? error.message : String(error)}`
+    );
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}

package/src/file/file-utils.test.ts

@@ -1,141 +1,141 @@
-/**
- * Unit Tests for File Utilities
- * 
- * Feature: dingtalk-media-receive
- * Validates: Requirements 5.1-5.8, 6.1-6.6
- */
-
-import { describe, it, expect } from "vitest";
-import { resolveFileCategory, resolveExtension } from "./file-utils.js";
-
-describe("resolveFileCategory", () => {
-  // Image categorization (Requirement 5.1)
-  it("should categorize image MIME types", () => {
-    expect(resolveFileCategory("image/jpeg")).toBe("image");
-    expect(resolveFileCategory("image/png")).toBe("image");
-    expect(resolveFileCategory("image/gif")).toBe("image");
-    expect(resolveFileCategory("image/webp")).toBe("image");
-    expect(resolveFileCategory("image/bmp")).toBe("image");
-  });
-
-  // Audio categorization (Requirement 5.2)
-  it("should categorize audio MIME types", () => {
-    expect(resolveFileCategory("audio/mpeg")).toBe("audio");
-    expect(resolveFileCategory("audio/wav")).toBe("audio");
-    expect(resolveFileCategory("audio/ogg")).toBe("audio");
-    expect(resolveFileCategory("audio/amr")).toBe("audio");
-  });
-
-  // Video categorization (Requirement 5.3)
-  it("should categorize video MIME types", () => {
-    expect(resolveFileCategory("video/mp4")).toBe("video");
-    expect(resolveFileCategory("video/quicktime")).toBe("video");
-    expect(resolveFileCategory("video/webm")).toBe("video");
-  });
-
-  // Document categorization (Requirement 5.4)
-  it("should categorize document MIME types", () => {
-    expect(resolveFileCategory("application/pdf")).toBe("document");
-    expect(resolveFileCategory("application/msword")).toBe("document");
-    expect(resolveFileCategory("text/plain")).toBe("document");
-    expect(resolveFileCategory("text/markdown")).toBe("document");
-  });
-
-  // Archive categorization (Requirement 5.5)
-  it("should categorize archive MIME types", () => {
-    expect(resolveFileCategory("application/zip")).toBe("archive");
-    expect(resolveFileCategory("application/x-rar-compressed")).toBe("archive");
-    expect(resolveFileCategory("application/x-7z-compressed")).toBe("archive");
-  });
-
-  // Code categorization (Requirement 5.6)
-  it("should categorize code MIME types", () => {
-    expect(resolveFileCategory("application/json")).toBe("code");
-    expect(resolveFileCategory("text/html")).toBe("code");
-    expect(resolveFileCategory("text/css")).toBe("code");
-    expect(resolveFileCategory("text/javascript")).toBe("code");
-  });
-
-  // Extension fallback (Requirement 5.8)
-  it("should use extension fallback when MIME type is unknown", () => {
-    expect(resolveFileCategory("application/octet-stream", "photo.jpg")).toBe("image");
-    expect(resolveFileCategory("application/octet-stream", "song.mp3")).toBe("audio");
-    expect(resolveFileCategory("application/octet-stream", "movie.mp4")).toBe("video");
-    expect(resolveFileCategory("application/octet-stream", "doc.pdf")).toBe("document");
-    expect(resolveFileCategory("application/octet-stream", "archive.zip")).toBe("archive");
-    expect(resolveFileCategory("application/octet-stream", "script.py")).toBe("code");
-  });
-
-  // Other category (Requirement 5.7)
-  it("should return 'other' for unknown types", () => {
-    expect(resolveFileCategory("application/octet-stream")).toBe("other");
-    expect(resolveFileCategory("application/unknown")).toBe("other");
-    expect(resolveFileCategory("application/octet-stream", "file.xyz")).toBe("other");
-  });
-
-  // MIME type normalization
-  it("should handle MIME types with parameters", () => {
-    expect(resolveFileCategory("image/jpeg; charset=utf-8")).toBe("image");
-    expect(resolveFileCategory("text/plain; charset=utf-8")).toBe("document");
-  });
-});
-
-describe("resolveExtension", () => {
-  // Image extensions (Requirement 6.1)
-  it("should resolve image MIME types to extensions", () => {
-    expect(resolveExtension("image/jpeg")).toBe(".jpg");
-    expect(resolveExtension("image/png")).toBe(".png");
-    expect(resolveExtension("image/gif")).toBe(".gif");
-    expect(resolveExtension("image/webp")).toBe(".webp");
-    expect(resolveExtension("image/bmp")).toBe(".bmp");
-  });
-
-  // Audio extensions (Requirement 6.2)
-  it("should resolve audio MIME types to extensions", () => {
-    expect(resolveExtension("audio/mpeg")).toBe(".mp3");
-    expect(resolveExtension("audio/wav")).toBe(".wav");
-    expect(resolveExtension("audio/ogg")).toBe(".ogg");
-    expect(resolveExtension("audio/amr")).toBe(".amr");
-    expect(resolveExtension("audio/x-m4a")).toBe(".m4a");
-  });
-
-  // Video extensions (Requirement 6.3)
-  it("should resolve video MIME types to extensions", () => {
-    expect(resolveExtension("video/mp4")).toBe(".mp4");
-    expect(resolveExtension("video/quicktime")).toBe(".mov");
-    expect(resolveExtension("video/x-msvideo")).toBe(".avi");
-    expect(resolveExtension("video/webm")).toBe(".webm");
-  });
-
-  // Document extensions (Requirement 6.4)
-  it("should resolve document MIME types to extensions", () => {
-    expect(resolveExtension("application/pdf")).toBe(".pdf");
-    expect(resolveExtension("application/msword")).toBe(".doc");
-    expect(resolveExtension("application/vnd.openxmlformats-officedocument.wordprocessingml.document")).toBe(".docx");
-  });
-
-  // Default extension (Requirement 6.5)
-  it("should return .bin for unknown MIME types", () => {
-    expect(resolveExtension("application/unknown")).toBe(".bin");
-    expect(resolveExtension("application/octet-stream")).toBe(".bin");
-  });
-
-  // fileName precedence (Requirement 6.6)
-  it("should use fileName extension when provided", () => {
-    expect(resolveExtension("application/octet-stream", "photo.jpg")).toBe(".jpg");
-    expect(resolveExtension("image/png", "custom.jpeg")).toBe(".jpeg");
-    expect(resolveExtension("application/unknown", "document.pdf")).toBe(".pdf");
-  });
-
-  // MIME type normalization
-  it("should handle MIME types with parameters", () => {
-    expect(resolveExtension("image/jpeg; charset=utf-8")).toBe(".jpg");
-    expect(resolveExtension("audio/mpeg; bitrate=320")).toBe(".mp3");
-  });
-
-  // Edge cases
-  it("should handle fileName without extension", () => {
-    expect(resolveExtension("image/jpeg", "photo")).toBe(".jpg");
-    expect(resolveExtension("application/unknown", "noext")).toBe(".bin");
-  });
-});
+/**
+ * Unit Tests for File Utilities
+ * 
+ * Feature: dingtalk-media-receive
+ * Validates: Requirements 5.1-5.8, 6.1-6.6
+ */
+
+import { describe, it, expect } from "vitest";
+import { resolveFileCategory, resolveExtension } from "./file-utils.js";
+
+describe("resolveFileCategory", () => {
+  // Image categorization (Requirement 5.1)
+  it("should categorize image MIME types", () => {
+    expect(resolveFileCategory("image/jpeg")).toBe("image");
+    expect(resolveFileCategory("image/png")).toBe("image");
+    expect(resolveFileCategory("image/gif")).toBe("image");
+    expect(resolveFileCategory("image/webp")).toBe("image");
+    expect(resolveFileCategory("image/bmp")).toBe("image");
+  });
+
+  // Audio categorization (Requirement 5.2)
+  it("should categorize audio MIME types", () => {
+    expect(resolveFileCategory("audio/mpeg")).toBe("audio");
+    expect(resolveFileCategory("audio/wav")).toBe("audio");
+    expect(resolveFileCategory("audio/ogg")).toBe("audio");
+    expect(resolveFileCategory("audio/amr")).toBe("audio");
+  });
+
+  // Video categorization (Requirement 5.3)
+  it("should categorize video MIME types", () => {
+    expect(resolveFileCategory("video/mp4")).toBe("video");
+    expect(resolveFileCategory("video/quicktime")).toBe("video");
+    expect(resolveFileCategory("video/webm")).toBe("video");
+  });
+
+  // Document categorization (Requirement 5.4)
+  it("should categorize document MIME types", () => {
+    expect(resolveFileCategory("application/pdf")).toBe("document");
+    expect(resolveFileCategory("application/msword")).toBe("document");
+    expect(resolveFileCategory("text/plain")).toBe("document");
+    expect(resolveFileCategory("text/markdown")).toBe("document");
+  });
+
+  // Archive categorization (Requirement 5.5)
+  it("should categorize archive MIME types", () => {
+    expect(resolveFileCategory("application/zip")).toBe("archive");
+    expect(resolveFileCategory("application/x-rar-compressed")).toBe("archive");
+    expect(resolveFileCategory("application/x-7z-compressed")).toBe("archive");
+  });
+
+  // Code categorization (Requirement 5.6)
+  it("should categorize code MIME types", () => {
+    expect(resolveFileCategory("application/json")).toBe("code");
+    expect(resolveFileCategory("text/html")).toBe("code");
+    expect(resolveFileCategory("text/css")).toBe("code");
+    expect(resolveFileCategory("text/javascript")).toBe("code");
+  });
+
+  // Extension fallback (Requirement 5.8)
+  it("should use extension fallback when MIME type is unknown", () => {
+    expect(resolveFileCategory("application/octet-stream", "photo.jpg")).toBe("image");
+    expect(resolveFileCategory("application/octet-stream", "song.mp3")).toBe("audio");
+    expect(resolveFileCategory("application/octet-stream", "movie.mp4")).toBe("video");
+    expect(resolveFileCategory("application/octet-stream", "doc.pdf")).toBe("document");
+    expect(resolveFileCategory("application/octet-stream", "archive.zip")).toBe("archive");
+    expect(resolveFileCategory("application/octet-stream", "script.py")).toBe("code");
+  });
+
+  // Other category (Requirement 5.7)
+  it("should return 'other' for unknown types", () => {
+    expect(resolveFileCategory("application/octet-stream")).toBe("other");
+    expect(resolveFileCategory("application/unknown")).toBe("other");
+    expect(resolveFileCategory("application/octet-stream", "file.xyz")).toBe("other");
+  });
+
+  // MIME type normalization
+  it("should handle MIME types with parameters", () => {
+    expect(resolveFileCategory("image/jpeg; charset=utf-8")).toBe("image");
+    expect(resolveFileCategory("text/plain; charset=utf-8")).toBe("document");
+  });
+});
+
+describe("resolveExtension", () => {
+  // Image extensions (Requirement 6.1)
+  it("should resolve image MIME types to extensions", () => {
+    expect(resolveExtension("image/jpeg")).toBe(".jpg");
+    expect(resolveExtension("image/png")).toBe(".png");
+    expect(resolveExtension("image/gif")).toBe(".gif");
+    expect(resolveExtension("image/webp")).toBe(".webp");
+    expect(resolveExtension("image/bmp")).toBe(".bmp");
+  });
+
+  // Audio extensions (Requirement 6.2)
+  it("should resolve audio MIME types to extensions", () => {
+    expect(resolveExtension("audio/mpeg")).toBe(".mp3");
+    expect(resolveExtension("audio/wav")).toBe(".wav");
+    expect(resolveExtension("audio/ogg")).toBe(".ogg");
+    expect(resolveExtension("audio/amr")).toBe(".amr");
+    expect(resolveExtension("audio/x-m4a")).toBe(".m4a");
+  });
+
+  // Video extensions (Requirement 6.3)
+  it("should resolve video MIME types to extensions", () => {
+    expect(resolveExtension("video/mp4")).toBe(".mp4");
+    expect(resolveExtension("video/quicktime")).toBe(".mov");
+    expect(resolveExtension("video/x-msvideo")).toBe(".avi");
+    expect(resolveExtension("video/webm")).toBe(".webm");
+  });
+
+  // Document extensions (Requirement 6.4)
+  it("should resolve document MIME types to extensions", () => {
+    expect(resolveExtension("application/pdf")).toBe(".pdf");
+    expect(resolveExtension("application/msword")).toBe(".doc");
+    expect(resolveExtension("application/vnd.openxmlformats-officedocument.wordprocessingml.document")).toBe(".docx");
+  });
+
+  // Default extension (Requirement 6.5)
+  it("should return .bin for unknown MIME types", () => {
+    expect(resolveExtension("application/unknown")).toBe(".bin");
+    expect(resolveExtension("application/octet-stream")).toBe(".bin");
+  });
+
+  // fileName precedence (Requirement 6.6)
+  it("should use fileName extension when provided", () => {
+    expect(resolveExtension("application/octet-stream", "photo.jpg")).toBe(".jpg");
+    expect(resolveExtension("image/png", "custom.jpeg")).toBe(".jpeg");
+    expect(resolveExtension("application/unknown", "document.pdf")).toBe(".pdf");
+  });
+
+  // MIME type normalization
+  it("should handle MIME types with parameters", () => {
+    expect(resolveExtension("image/jpeg; charset=utf-8")).toBe(".jpg");
+    expect(resolveExtension("audio/mpeg; bitrate=320")).toBe(".mp3");
+  });
+
+  // Edge cases
+  it("should handle fileName without extension", () => {
+    expect(resolveExtension("image/jpeg", "photo")).toBe(".jpg");
+    expect(resolveExtension("application/unknown", "noext")).toBe(".bin");
+  });
+});