cj-tauri 1.1.2 → 2.1.0

package/src/plugins/log/plugin_log.cj

@@ -1,105 +1,105 @@
-package cjTauri.plugins.log
-
-import cjTauri.*
-
-import std.collection.*
-import stdx.encoding.json.*
-
-/**
- * 官方插件 log：把**前端**的诊断并进宿主日志（RFC-003 第 5 期）
- *
- * 命令：log:write（追加一行）/ log:path（回读生效中的日志文件，空串＝没开）
- * 权限：**不自动放行**，应用在 capabilities 里显式声明，两种写法等价：
- *   "commands": ["log:write", "log:path"]   // 明文逐条
- *   "permissions": ["log:default"]          // 命名权限集（两条都放行）
- * 前端：window.__CJ_TAURI__.log.write("...") / log.path()
- *
- * 为什么需要它：框架的落盘接管的是 **C 桥与仓颉侧**的 stderr，而页面里的 JS 报错在交付给
- * 用户的单文件产物里同样无处可去（GUI 子系统、双击没有控制台）。插件把页面诊断经命令
- * 送回宿主，落进**同一份**文件——报障时只看一个文件，不用两台机器对着时间戳拼。
- *
- * shim 顺带装上 `error` / `unhandledrejection` 两个钩子：页面自己没写日志也能留下异常。
- * 钩子里**必须吞掉** invoke 的失败（命令未放行时它会 reject），否则钩子自己又造出一轮
- * 未捕获拒绝，转成停不下来的自激。
- */
-public class LogPlugin <: Plugin {
-    public init() {}
-
-    public func name(): String {
-        return "log"
-    }
-
-    public func commands(): HashMap<String, CommandHandler> {
-        let m = HashMap<String, CommandHandler>()
-        // 键写**短名**：前缀由框架补（写全名会得到 log:log:write，且所有命令都成未注册）
-        m.add("write", LogCommands())
-        m.add("path", LogCommands())
-        return m
-    }
-
-    /** 命名权限集（v1.1）：default = 写 + 回读路径（回读能问到本机目录布局，不该默认放宽） */
-    public func permissions(): HashMap<String, ArrayList<String>> {
-        let m = HashMap<String, ArrayList<String>>()
-        let all = ArrayList<String>()
-        all.add("write")
-        all.add("path")
-        m.add("default", all)
-        return m
-    }
-
-    /**
-     * 前端 shim：`__CJ_TAURI__.log` + 两个全局异常钩子（都在 document-start 装，早于页面脚本）
-     *
-     * 内联 JS 里**不出现反斜杠**（转义会先被仓颉吃掉，AGENTS §4）；拼接用 `+`，
-     * 不用模板串，免得 `${}` 撞上仓颉的字符串插值。
-     */
-    public func jsShim(): String {
-        return "(function () { var t = window.__CJ_TAURI__ || (window.__CJ_TAURI__ = {});" +
-            " t.log = {" +
-            " write: function (line) { return window.__CJ_TAURI__.invoke('log:write', { line: String(line) }); }," +
-            " path: function () { return window.__CJ_TAURI__.invoke('log:path', {}); }" +
-            " };" +
-            " var push = function (line) { try { var p = t.log.write(line);" +
-            " if (p && p.catch) { p.catch(function () {}); } } catch (e) {} };" +
-            " window.addEventListener('error', function (ev) {" +
-            " var where = ev.filename ? (ev.filename + ':' + ev.lineno + ':' + ev.colno) : 'unknown';" +
-            " push('[frontend] error: ' + (ev.message || 'unknown') + ' @ ' + where); });" +
-            " window.addEventListener('unhandledrejection', function (ev) {" +
-            " push('[frontend] unhandled rejection: ' + String(ev.reason)); });" +
-            " })();\n"
-    }
-}
-
-/** 日志命令处理器：write 收 { line }，path 无参 */
-public class LogCommands <: CommandHandler {
-    public init() {}
-
-    public func handle(cmd: String, args: JsonObject, ipc: IpcContext): JsonValue {
-        let _ = ipc
-        match (cmd) {
-            case "log:write" =>
-                let line = this.requireString(args, "line")
-                if (line.size > CJ_LOG_MAX_LINE) {
-                    // 不按字节切字符串（会把汉字切碎）：超长就只记一条说明，
-                    // 免得页面用一行天文数字把内存和日志文件一起撑爆
-                    let note = "[frontend] log line dropped: ${line.size} bytes exceeds ${CJ_LOG_MAX_LINE}"
-                    return JsonBool(writeLogLine(note))
-                }
-                // false = 没开日志（这一轮没落盘），不是错误：页面照常跑，别让它变成 reject
-                return JsonBool(writeLogLine(line))
-            case "log:path" =>
-                return JsonString(currentLogFilePath()) // 空串 = 没开
-            case _ => throw CommandException("unknown log command: ${cmd}")
-        }
-    }
-
-    private func requireString(args: JsonObject, key: String): String {
-        match (args.get(key)) {
-            case Some(v) => match (v.kind()) {
-                case JsonKind.JsString => return v.asString().getValue()
-                case _ => throw CommandException("log: argument \"${key}\" must be a string")
-            }
-            case None => throw CommandException("log: missing argument \"${key}\"")
-        }
-    }
-}
+package cjTauri.plugins.log
+
+import cjTauri.*
+
+import std.collection.*
+import stdx.encoding.json.*
+
+/**
+ * 官方插件 log：把**前端**的诊断并进宿主日志（RFC-003 第 5 期）
+ *
+ * 命令：log:write（追加一行）/ log:path（回读生效中的日志文件，空串＝没开）
+ * 权限：**不自动放行**，应用在 capabilities 里显式声明，两种写法等价：
+ *   "commands": ["log:write", "log:path"]   // 明文逐条
+ *   "permissions": ["log:default"]          // 命名权限集（两条都放行）
+ * 前端：window.__CJ_TAURI__.log.write("...") / log.path()
+ *
+ * 为什么需要它：框架的落盘接管的是 **C 桥与仓颉侧**的 stderr，而页面里的 JS 报错在交付给
+ * 用户的单文件产物里同样无处可去（GUI 子系统、双击没有控制台）。插件把页面诊断经命令
+ * 送回宿主，落进**同一份**文件——报障时只看一个文件，不用两台机器对着时间戳拼。
+ *
+ * shim 顺带装上 `error` / `unhandledrejection` 两个钩子：页面自己没写日志也能留下异常。
+ * 钩子里**必须吞掉** invoke 的失败（命令未放行时它会 reject），否则钩子自己又造出一轮
+ * 未捕获拒绝，转成停不下来的自激。
+ */
+public class LogPlugin <: Plugin {
+    public init() {}
+
+    public func name(): String {
+        return "log"
+    }
+
+    public func commands(): HashMap<String, CommandHandler> {
+        let m = HashMap<String, CommandHandler>()
+        // 键写**短名**：前缀由框架补（写全名会得到 log:log:write，且所有命令都成未注册）
+        m.add("write", LogCommands())
+        m.add("path", LogCommands())
+        return m
+    }
+
+    /** 命名权限集（v1.1）：default = 写 + 回读路径（回读能问到本机目录布局，不该默认放宽） */
+    public func permissions(): HashMap<String, ArrayList<String>> {
+        let m = HashMap<String, ArrayList<String>>()
+        let all = ArrayList<String>()
+        all.add("write")
+        all.add("path")
+        m.add("default", all)
+        return m
+    }
+
+    /**
+     * 前端 shim：`__CJ_TAURI__.log` + 两个全局异常钩子（都在 document-start 装，早于页面脚本）
+     *
+     * 内联 JS 里**不出现反斜杠**（转义会先被仓颉吃掉，AGENTS §4）；拼接用 `+`，
+     * 不用模板串，免得 `${}` 撞上仓颉的字符串插值。
+     */
+    public func jsShim(): String {
+        return "(function () { var t = window.__CJ_TAURI__ || (window.__CJ_TAURI__ = {});" +
+            " t.log = {" +
+            " write: function (line) { return window.__CJ_TAURI__.invoke('log:write', { line: String(line) }); }," +
+            " path: function () { return window.__CJ_TAURI__.invoke('log:path', {}); }" +
+            " };" +
+            " var push = function (line) { try { var p = t.log.write(line);" +
+            " if (p && p.catch) { p.catch(function () {}); } } catch (e) {} };" +
+            " window.addEventListener('error', function (ev) {" +
+            " var where = ev.filename ? (ev.filename + ':' + ev.lineno + ':' + ev.colno) : 'unknown';" +
+            " push('[frontend] error: ' + (ev.message || 'unknown') + ' @ ' + where); });" +
+            " window.addEventListener('unhandledrejection', function (ev) {" +
+            " push('[frontend] unhandled rejection: ' + String(ev.reason)); });" +
+            " })();\n"
+    }
+}
+
+/** 日志命令处理器：write 收 { line }，path 无参 */
+public class LogCommands <: CommandHandler {
+    public init() {}
+
+    public func handle(cmd: String, args: JsonObject, ipc: IpcContext): JsonValue {
+        let _ = ipc
+        match (cmd) {
+            case "log:write" =>
+                let line = this.requireString(args, "line")
+                if (line.size > CJ_LOG_MAX_LINE) {
+                    // 不按字节切字符串（会把汉字切碎）：超长就只记一条说明，
+                    // 免得页面用一行天文数字把内存和日志文件一起撑爆
+                    let note = "[frontend] log line dropped: ${line.size} bytes exceeds ${CJ_LOG_MAX_LINE}"
+                    return JsonBool(writeLogLine(note))
+                }
+                // false = 没开日志（这一轮没落盘），不是错误：页面照常跑，别让它变成 reject
+                return JsonBool(writeLogLine(line))
+            case "log:path" =>
+                return JsonString(currentLogFilePath()) // 空串 = 没开
+            case _ => throw CommandException("unknown log command: ${cmd}")
+        }
+    }
+
+    private func requireString(args: JsonObject, key: String): String {
+        match (args.get(key)) {
+            case Some(v) => match (v.kind()) {
+                case JsonKind.JsString => return v.asString().getValue()
+                case _ => throw CommandException("log: argument \"${key}\" must be a string")
+            }
+            case None => throw CommandException("log: missing argument \"${key}\"")
+        }
+    }
+}

package/src/plugins/menu/plugin_menu.cj

@@ -33,6 +33,14 @@ public class MenuPlugin <: Plugin {
         return "menu"
     }
 
+    /** 自描述：菜单状态改动是宿主能力，仅桌面两端实现（ohos 宿主无菜单栏，命令如实报错，P-1/P-2） */
+    public func describe(): PluginManifest {
+        let hosts = ArrayList<String>()
+        hosts.add("webkitgtk")
+        hosts.add("webview2")
+        return PluginManifest(hosts, ArrayList<String>())
+    }
+
     public func commands(): HashMap<String, CommandHandler> {
         let m = HashMap<String, CommandHandler>()
         m.add("setEnabled", this.handler)

package/src/plugins/notification/plugin_notification.cj

@@ -1,146 +1,154 @@
-package cjTauri.plugins.notification
-
-import cjTauri.*
-
-import std.collection.*
-import stdx.encoding.json.*
-
-/**
- * 官方插件 notification：系统通知（对标 Tauri 的 notification 插件，RFC-003 第 3 期）
- *
- * 命令：notification:notify
- * 权限：**不自动放行**，应用要在 capabilities 里显式声明：
- *   "commands": ["notification:notify"]
- *   "permissions": ["notification:default"]
- * 前端：window.__CJ_TAURI__.notification.notify({ title, body })
- *
- * 实现落 C 桥 `cj_bridge_notification_notify`：Linux 走 freedesktop Notifications
- * （会话总线）；**Windows 桩阶段返回 -4 未实现**——命令如实报失败，`system:host` 的能力位
- * 同口径不置 CJ_CAP_NOTIFICATION，不假装成功（AGENTS §1 的如实交付口径）。
- *
- * 「发后即忘」：提交即返回，通知显示与否不回传（freedesktop 协议本就没有同步回执）。
- */
-public class NotificationPlugin <: Plugin {
-    private let handler: NotificationCommands = NotificationCommands()
-
-    public init() {}
-
-    public func name(): String {
-        return "notification"
-    }
-
-    public func commands(): HashMap<String, CommandHandler> {
-        let m = HashMap<String, CommandHandler>()
-        m.add("notify", this.handler)
-        return m
-    }
-
-    /**
-     * 命名权限集（v1.1）：只有一条命令，default 与明文等价——保留集名是为了
-     * 应用清单写法统一（全部走 permissions 数组）。
-     */
-    public func permissions(): HashMap<String, ArrayList<String>> {
-        let m = HashMap<String, ArrayList<String>>()
-        let all = ArrayList<String>()
-        all.add("notify")
-        m.add("default", all)
-        return m
-    }
-
-    /**
-     * 前端 shim：往桥对象上挂一个 notification 命名空间（与 dialog 同款）
-     */
-    public func jsShim(): String {
-        return "(function () { var t = window.__CJ_TAURI__ || (window.__CJ_TAURI__ = {});" +
-            " t.notification = {" +
-            " notify: function (o) { return window.__CJ_TAURI__.invoke('notification:notify', o || {}); }" +
-            " }; })();\n"
-    }
-
-    public func setup(app: TauriApp): Unit {
-        // 多窗口按报文里的 label 解析宿主（与 dialog 插件同一口径）：固定 `app.webviewHost()`
-        // 会让第二扇窗的通知全部落到默认窗那一个宿主上（2026-10-20 dialog 实机取证同款）。
-        this.handler.attachHostResolver({ label => app.hostOf(label) })
-    }
-}
-
-/**
- * 通知命令处理器：notify 收 { title, body? }。body 省略 / null 都合法。
- */
-public class NotificationCommands <: CommandHandler {
-    private var host: Option<WebViewHost> = None
-
-    /* 按 label 解析宿主（多窗口的正路）：单槽 `host` 只记着装配时那一个宿主，
-       多窗口下用它就是「所有窗的通知都发给默认窗那一个宿主」。 */
-    private var hostByWindow: Option<(String) -> Option<WebViewHost>> = None
-
-    public init() {}
-
-    /** 由 NotificationPlugin.setup() 调用（单窗口 / 单测用；这个槽不带窗口身份） */
-    public func attachHost(h: WebViewHost): Unit {
-        this.host = Some(h)
-    }
-
-    /** 装配「label → 宿主」解析器；由 NotificationPlugin.setup() 传入 `app.hostOf` */
-    public func attachHostResolver(resolve: (String) -> Option<WebViewHost>): Unit {
-        this.hostByWindow = Some(resolve)
-    }
-
-    public func handle(cmd: String, args: JsonObject, ipc: IpcContext): JsonValue {
-        match (cmd) {
-            case "notification:notify" =>
-                let title = this.requireString(args, "title")
-                let body = this.optionalString(args, "body")
-                if (this.requireHost(ipc).notify(title, body)) {
-                    return JsonNull()
-                }
-                throw CommandException(
-                    "notification: 发送失败（宿主未就绪 / 本平台未实现 / 桌面环境不可用）")
-            case _ => throw CommandException("unknown notification command: ${cmd}")
-        }
-    }
-
-    /**
-     * 取**发起这条命令的窗口**的宿主
-     *
-     * 多窗口下必须按 `ipc.window` 解析：用装配时那一个宿主，第二扇窗的通知会落到默认窗的宿主上。
-     * 解析器在场而窗口没登记时**如实报错**，不回落到单槽（与 dialog 插件同一口径）。
-     */
-    private func requireHost(ipc: IpcContext): WebViewHost {
-        match (this.hostByWindow) {
-            case Some(resolve) => match (resolve(ipc.window)) {
-                case Some(h) => return h
-                case None => throw CommandException(
-                    "notification: 窗口 \"${ipc.window}\" 没有登记宿主（addWindow(); 默认窗在 run() 之前也可用）")
-            }
-            case None => ()
-        }
-        match (this.host) {
-            case Some(h) => h
-            case None => throw CommandException(
-                "notification: 宿主未装配（用 .plugin(NotificationPlugin()) 装配插件后才可用）")
-        }
-    }
-
-    private func requireString(args: JsonObject, key: String): String {
-        match (args.get(key)) {
-            case Some(v) => match (v.kind()) {
-                case JsonKind.JsString => return v.asString().getValue()
-                case _ => throw CommandException("notification: argument \"${key}\" must be a string")
-            }
-            case None => throw CommandException("notification: missing argument \"${key}\"")
-        }
-    }
-
-    /** 可选字符串参数：缺失 / null 都按空串（body 可省） */
-    private func optionalString(args: JsonObject, key: String): String {
-        match (args.get(key)) {
-            case Some(v) => match (v.kind()) {
-                case JsonKind.JsString => return v.asString().getValue()
-                case JsonKind.JsNull => return ""
-                case _ => throw CommandException("notification: argument \"${key}\" must be a string")
-            }
-            case None => return ""
-        }
-    }
-}
+package cjTauri.plugins.notification
+
+import cjTauri.*
+
+import std.collection.*
+import stdx.encoding.json.*
+
+/**
+ * 官方插件 notification：系统通知（对标 Tauri 的 notification 插件，RFC-003 第 3 期）
+ *
+ * 命令：notification:notify
+ * 权限：**不自动放行**，应用要在 capabilities 里显式声明：
+ *   "commands": ["notification:notify"]
+ *   "permissions": ["notification:default"]
+ * 前端：window.__CJ_TAURI__.notification.notify({ title, body })
+ *
+ * 实现落 C 桥 `cj_bridge_notification_notify`：Linux 走 freedesktop Notifications
+ * （会话总线）；**Windows 桩阶段返回 -4 未实现**——命令如实报失败，`system:host` 的能力位
+ * 同口径不置 CJ_CAP_NOTIFICATION，不假装成功（AGENTS §1 的如实交付口径）。
+ *
+ * 「发后即忘」：提交即返回，通知显示与否不回传（freedesktop 协议本就没有同步回执）。
+ */
+public class NotificationPlugin <: Plugin {
+
+    /** 自描述：原生桥仅桌面两端实现（ohos 侧按 P-1 落桩，批次 3-PR3） */
+    public func describe(): PluginManifest {
+        let hosts = ArrayList<String>()
+        hosts.add("webkitgtk")
+        hosts.add("webview2")
+        return PluginManifest(hosts, ArrayList<String>())
+    }
+    private let handler: NotificationCommands = NotificationCommands()
+
+    public init() {}
+
+    public func name(): String {
+        return "notification"
+    }
+
+    public func commands(): HashMap<String, CommandHandler> {
+        let m = HashMap<String, CommandHandler>()
+        m.add("notify", this.handler)
+        return m
+    }
+
+    /**
+     * 命名权限集（v1.1）：只有一条命令，default 与明文等价——保留集名是为了
+     * 应用清单写法统一（全部走 permissions 数组）。
+     */
+    public func permissions(): HashMap<String, ArrayList<String>> {
+        let m = HashMap<String, ArrayList<String>>()
+        let all = ArrayList<String>()
+        all.add("notify")
+        m.add("default", all)
+        return m
+    }
+
+    /**
+     * 前端 shim：往桥对象上挂一个 notification 命名空间（与 dialog 同款）
+     */
+    public func jsShim(): String {
+        return "(function () { var t = window.__CJ_TAURI__ || (window.__CJ_TAURI__ = {});" +
+            " t.notification = {" +
+            " notify: function (o) { return window.__CJ_TAURI__.invoke('notification:notify', o || {}); }" +
+            " }; })();\n"
+    }
+
+    public func setup(app: TauriApp): Unit {
+        // 多窗口按报文里的 label 解析宿主（与 dialog 插件同一口径）：固定 `app.webviewHost()`
+        // 会让第二扇窗的通知全部落到默认窗那一个宿主上（2026-10-20 dialog 实机取证同款）。
+        this.handler.attachHostResolver({ label => app.hostOf(label) })
+    }
+}
+
+/**
+ * 通知命令处理器：notify 收 { title, body? }。body 省略 / null 都合法。
+ */
+public class NotificationCommands <: CommandHandler {
+    private var host: Option<WebViewHost> = None
+
+    /* 按 label 解析宿主（多窗口的正路）：单槽 `host` 只记着装配时那一个宿主，
+       多窗口下用它就是「所有窗的通知都发给默认窗那一个宿主」。 */
+    private var hostByWindow: Option<(String) -> Option<WebViewHost>> = None
+
+    public init() {}
+
+    /** 由 NotificationPlugin.setup() 调用（单窗口 / 单测用；这个槽不带窗口身份） */
+    public func attachHost(h: WebViewHost): Unit {
+        this.host = Some(h)
+    }
+
+    /** 装配「label → 宿主」解析器；由 NotificationPlugin.setup() 传入 `app.hostOf` */
+    public func attachHostResolver(resolve: (String) -> Option<WebViewHost>): Unit {
+        this.hostByWindow = Some(resolve)
+    }
+
+    public func handle(cmd: String, args: JsonObject, ipc: IpcContext): JsonValue {
+        match (cmd) {
+            case "notification:notify" =>
+                let title = this.requireString(args, "title")
+                let body = this.optionalString(args, "body")
+                if (this.requireHost(ipc).notify(title, body)) {
+                    return JsonNull()
+                }
+                throw CommandException(
+                    "notification: 发送失败（宿主未就绪 / 本平台未实现 / 桌面环境不可用）")
+            case _ => throw CommandException("unknown notification command: ${cmd}")
+        }
+    }
+
+    /**
+     * 取**发起这条命令的窗口**的宿主
+     *
+     * 多窗口下必须按 `ipc.window` 解析：用装配时那一个宿主，第二扇窗的通知会落到默认窗的宿主上。
+     * 解析器在场而窗口没登记时**如实报错**，不回落到单槽（与 dialog 插件同一口径）。
+     */
+    private func requireHost(ipc: IpcContext): WebViewHost {
+        match (this.hostByWindow) {
+            case Some(resolve) => match (resolve(ipc.window)) {
+                case Some(h) => return h
+                case None => throw CommandException(
+                    "notification: 窗口 \"${ipc.window}\" 没有登记宿主（addWindow(); 默认窗在 run() 之前也可用）")
+            }
+            case None => ()
+        }
+        match (this.host) {
+            case Some(h) => h
+            case None => throw CommandException(
+                "notification: 宿主未装配（用 .plugin(NotificationPlugin()) 装配插件后才可用）")
+        }
+    }
+
+    private func requireString(args: JsonObject, key: String): String {
+        match (args.get(key)) {
+            case Some(v) => match (v.kind()) {
+                case JsonKind.JsString => return v.asString().getValue()
+                case _ => throw CommandException("notification: argument \"${key}\" must be a string")
+            }
+            case None => throw CommandException("notification: missing argument \"${key}\"")
+        }
+    }
+
+    /** 可选字符串参数：缺失 / null 都按空串（body 可省） */
+    private func optionalString(args: JsonObject, key: String): String {
+        match (args.get(key)) {
+            case Some(v) => match (v.kind()) {
+                case JsonKind.JsString => return v.asString().getValue()
+                case JsonKind.JsNull => return ""
+                case _ => throw CommandException("notification: argument \"${key}\" must be a string")
+            }
+            case None => return ""
+        }
+    }
+}

package/src/plugins/serial/plugin_serial.cj

@@ -3,7 +3,10 @@ package cjTauri.plugins.serial
 import cjTauri.*
 
 import std.collection.*
+// std.fs / std.sort 被 serialPortList 用到（桌面走 C 桥枚举回落 + 目录扫描；ohos 走 serial_ohos.cj 的扫描）
+@When[env != "ohos"]
 import std.fs.*
+@When[env != "ohos"]
 import std.sort.*
 import stdx.encoding.json.*
 
@@ -37,6 +40,7 @@ let SERIAL_LIST_PREFIXES: Array<String> = [
  * Windows 优先走 C 桥的 QueryDosDeviceW 枚举（返回的是「COM 名」，页面直接当 path 用，
  * C 桥 open 会自动补 \\.\\ 前缀）；C 桥返回 -4（未实现）或异常时回落到 /dev 目录扫描——
  * 后者在 Windows 下天然为空，不算错误。 */
+@When[env != "ohos"]
 public func serialPortList(): ArrayList<String> {
     let viaC = serialListC()
     if (let Some(list) <- viaC) {
@@ -78,6 +82,15 @@ public func serialPortList(): ArrayList<String> {
 public class SerialPlugin <: Plugin {
     public init() {}
 
+    /** 自描述：桌面两端走 C 桥、ohos 走 NDK FFI 直连（serial_ohos.cj），三端都实现 */
+    public func describe(): PluginManifest {
+        let hosts = ArrayList<String>()
+        hosts.add("webkitgtk")
+        hosts.add("webview2")
+        hosts.add("arkweb")
+        return PluginManifest(hosts, ArrayList<String>())
+    }
+
     public func name(): String {
         return "serial"
     }
@@ -140,10 +153,13 @@ let SERIAL_BAUDS: Array<Int32> = [300, 600, 1200, 2400, 4800, 9600, 19200, 38400
     230400, 460800, 500000, 921600, 1000000]
 
 /**
- * 设备路径前缀白名单：与 native/bridge_core.c 的 CJ_SERIAL_PREFIXES 对齐
+ * 设备路径前缀白名单：与 native/bridge_core.c 的 CJ_SERIAL_PREFIXES 对齐；
+ * /dev/bus/tty* 是鸿蒙特有的 USB 串口落点（桌面 C 桥白名单没有它们，但桌面侧不会出现
+ * 这类路径，加了不影响；ohos 侧的真正边界在 serial_ohos.cj 的 open，白名单同源）
  */
 let SERIAL_PATH_PREFIXES: Array<String> = ["/dev/ttyUSB", "/dev/ttyACM", "/dev/ttyS", "/dev/ttyAMA",
     "/dev/ttyPS", "/dev/ttyTHS", "/dev/ttyXRUSB", "/dev/ttyV", "/dev/tty.", "/dev/cu.",
+    "/dev/bus/ttyUSB", "/dev/bus/ttyACM", "/dev/bus/ttyS",
     "/dev/serial/by-id/", "/dev/serial/by-path/", "/dev/pts/", "COM", "\\\\.\\COM"]
 
 public func serialBaudSupported(baud: Int32): Bool {

package/src/plugins/serial/serial_bridge.cj

@@ -1,6 +1,8 @@
 package cjTauri.plugins.serial
 
-
+// 桌面两端包装函数用（ohos 走 NDK FFI 直连，实现在 serial_ohos.cj，批次 4）；
+// foreign 声明不带门禁：ohos 侧无引用即不要求符号，不产生链接错误
+@When[env != "ohos"]
 import std.collection.*
 
 /**
@@ -57,6 +59,7 @@ foreign func cj_bridge_serial_list(buf: CPointer<UInt8>, bufLen: Int32): Int32
  * 打开串口：成功返回 >0 句柄，失败返回负码（-1 参数/白名单、-2 句柄表满、-3 平台打不开）。
  * 失败明细用 serialLastError() 取（C 侧线程局部，同一线程内取才有意义）。
  */
+@When[env != "ohos"]
 public func serialOpen(path: String, baud: Int32, dataBits: Int32, parity: Int32,
                        stopBits: Int32): Int64 {
     var h: Int64 = -1
@@ -73,6 +76,7 @@ public func serialOpen(path: String, baud: Int32, dataBits: Int32, parity: Int32
 /**
  * C 侧最近一次失败的明细；取不到时返回空串（调用方自行降级成数字码）
  */
+@When[env != "ohos"]
 public func serialLastError(): String {
     unsafe {
         return cj_bridge_serial_last_error().toString()
@@ -83,6 +87,7 @@ public func serialLastError(): String {
  * C 桥枚举本机串口：Windows 下走 QueryDosDeviceW（返回 COM 名字列表）；
  * Linux 返回 None（-4 未实现，serial:list 在 Linux 走 /dev 扫描）。C 侧异常时也回 None。
  */
+@When[env != "ohos"]
 public func serialListC(): Option<ArrayList<String>> {
     let cap: Int32 = 8192
     let buf = LibC.malloc<UInt8>(count: Int64(cap))
@@ -128,6 +133,7 @@ public func serialListC(): Option<ArrayList<String>> {
  * 读：最多 maxBytes 字节。返回实际读到的字节（空数组 = 超时无数据）。
  * 缓冲在这里现分配现释放——每次读的用量都很小，不值得为它引一层对象池。
  */
+@When[env != "ohos"]
 public func serialRead(h: Int64, maxBytes: Int32, timeoutMs: Int32): Array<UInt8> {
     let cap = Int64(maxBytes)
     let buf = LibC.malloc<UInt8>(count: cap)
@@ -153,6 +159,7 @@ public func serialRead(h: Int64, maxBytes: Int32, timeoutMs: Int32): Array<UInt8
 /**
  * 写：在 timeoutMs 预算内尽量写完，返回实际写入字节数（可能 < data.size；0 = 一个字节都没出去）
  */
+@When[env != "ohos"]
 public func serialWrite(h: Int64, data: Array<UInt8>, timeoutMs: Int32): Int32 {
     if (data.size == 0) {
         return 0
@@ -177,6 +184,7 @@ public func serialWrite(h: Int64, data: Array<UInt8>, timeoutMs: Int32): Int32 {
 /**
  * 关句柄：0 = 成功，负码 = 失败（重复关返回 -4）
  */
+@When[env != "ohos"]
 public func serialClose(h: Int64): Int32 {
     var rc: Int32 = 0
     unsafe {