@forsion/unit 2.12.2

package/LICENSE

@@ -0,0 +1,223 @@
+# Open Source License
+
+Forsion Genesis is licensed under a modified version of the Apache License 2.0, with the following additional conditions:
+
+1. Forsion Genesis may be used commercially, including as a backend service for other applications, as an application development platform, or as the foundation for enterprise deployments. Should any of the conditions below apply, a commercial license must be obtained from the producer:
+
+   a. Multi-tenant service: unless explicitly authorized by Forsion in writing, you may not use the Forsion Genesis source code — including the `tangu-agent` engine, the `lcl` framework, and the `desktop` / `web` / `mobile` applications in this repository — to operate a multi-tenant environment.
+      - Tenant Definition: within the context of Forsion Genesis, one tenant corresponds to one workspace or one user account. A workspace/account provides a separated area for that tenant's data and configuration.
+
+   b. LOGO and copyright information: when using Forsion Genesis's frontend applications (`desktop/`, `web/`, or `mobile/`), you may not remove or modify the LOGO, product name, or copyright information shown in the application UI. This restriction does not apply to uses of Forsion Genesis that do not involve these frontends — for example, using the `tangu-agent` engine purely as a headless backend or library.
+
+2. As a contributor, you agree that:
+
+   a. The producer may adjust this license to be more strict or more permissive as it deems necessary.
+   b. Your contributed code may be used for commercial purposes by the producer, including but not limited to its own cloud/hosted operations.
+
+Apart from the conditions above, all other rights and restrictions follow the Apache License 2.0. The full text of the Apache License 2.0 is reproduced below and is also available at http://www.apache.org/licenses/LICENSE-2.0.
+
+Copyright © 2026 Hangzhou Niangshishan Technology Co., Ltd. (杭州酿诗山科技有限责任公司)
+
+---
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,101 @@
+# Forsion Unit
+
+Unit 是独立运行的 Forsion 基础框架，复用 Genesis Desktop 的界面、笔记处理器与 Tangu 引擎。它提供插件宿主和 Web UI；已安装的插件决定业务功能。本分支与独立发行包不包含商业 Forsion Server、Admin 管理界面或商业部署组合，相关产品在独立仓库装配。
+
+Unit is the independently runnable Forsion framework, sharing the Genesis Desktop renderer, note handlers and Tangu engine. It provides the plugin host and Web UI; installed plugins supply business capabilities. This branch and its standalone releases exclude the commercial Forsion Server, its Admin UI and commercial deployment compositions. Those products are assembled in separate repositories.
+
+## Desktop 同步 / Desktop synchronization
+
+Desktop 基线不再手工维护：构建时由 git 推导，取检出历史里最新的 `v*` 稳定版标签作基线，距它的提交数作 Unit 修订号。同步方向为 Desktop → Unit；共享功能复用源码，Unit 维护宿主适配。本分支不向 Desktop 主线自动回合，也不从商业 Server 仓库同步代码。
+
+The Desktop baseline is no longer hand-maintained: the build derives it from git, taking the newest `v*` stable tag contained in the checkout as the baseline and the number of commits since it as the Unit revision. Synchronization flows from Desktop into Unit. Shared features reuse source code; Unit maintains its host adapters. This branch does not automatically merge back into Desktop or import the commercial Server repository.
+
+```sh
+# Refresh upstream refs, then inspect drift without changing source.
+git fetch origin main --tags
+node unit/check-sync.mjs
+```
+
+发现新稳定版后，合并对应标签并处理冲突，运行类型、插件、账号和本地安装验收，再构建发行。尤其检查已抽取的共享处理器是否接到了上游修复。构建前的检查只拦一种情况：仓里已有比当前检出更新的稳定版标签而它不在 HEAD 历史里（在旧检出上打包）。不是恰好在稳定版标签提交上的构建（有后续提交，或 package.json 版本已越过标签）都记为预发布，写进 `release.json` 而不报错；package.json 版本低于基线标签则拒绝。检查基于已获取的标签；它不会自行联网或自动合并。
+
+When a new stable release is available, merge its tag, resolve conflicts, and run type, plugin, account and local installation checks before building. Verify that fixes in extracted shared handlers are carried forward. The pre-build check refuses exactly one situation: a newer stable tag exists in the repository but not in HEAD's history (packaging from a stale checkout). Any build that is not exactly the tagged commit (later commits, or a package version already bumped past the tag) is recorded in `release.json` as a pre-release rather than refused; a package version behind the baseline tag is refused. It checks fetched tags and does not fetch or merge automatically.
+
+`.github/workflows/check-unit.yml` 提供分支检查和手动构建；发行包中的 `release.json` 记录 Desktop 基线标签与提交、Unit 修订号、是否预发布及源码提交。检查本身不发布版本。
+
+`.github/workflows/check-unit.yml` provides branch validation and manual builds. Each distribution contains `release.json` with its Desktop baseline tag and commit, Unit revision, pre-release flag and source commit. Validation does not publish a release.
+
+## 构建与安装 / Build and install
+
+```sh
+# Framework + Web UI only.
+node unit/build.mjs --package
+# Framework + Web UI + optional local business plugin packages.
+node unit/build.mjs --package --local-plugins
+```
+
+构建使用全新的暂存目录，通过检查后替换 `unit/dist`，不会继承旧发行目录中的额外插件。构建失败保留上一份完整发行。依赖安装后可直接构建，无需商业后端源码、数据库或凭据。Node 20+ 可运行框架；插件的原生依赖须匹配目标系统、CPU 和 Node ABI。
+
+Builds use a fresh staging directory and replace `unit/dist` after validation, preventing leftover plugins from entering the next release. Failed builds preserve the previous distribution. Once dependencies are installed, building requires no commercial backend source, database or credentials. The framework runs on Node 20+; native plugin dependencies must match the target OS, CPU and Node ABI.
+
+复制整个 `unit/dist` 到设备后，在发行目录中执行：
+
+Copy the entire `unit/dist` directory to the device, then run from that directory:
+
+```sh
+node main.mjs init /absolute/path/my-unit --mode local --port 3002 --base /web/
+node main.mjs install /absolute/path/my-unit/unit.json ./plugins/amadeus
+node main.mjs install /absolute/path/my-unit/unit.json ./plugins/tangu
+node main.mjs install /absolute/path/my-unit/unit.json ./plugins/calendar
+node main.mjs run /absolute/path/my-unit/unit.json
+# From another terminal, get this device owner's browser access link.
+node main.mjs access /absolute/path/my-unit/unit.json
+```
+
+`--local-plugins` 提供 Amadeus、Tangu、Calendar、Automation、Public 的安装包，安装哪些由设备所有者决定。Amadeus 和 Tangu 包含本地运行实现；`unit/plugins` 中的源 manifest 仅为前端声明，不等于完整本地运行包。
+
+`--local-plugins` supplies Amadeus, Tangu, Calendar, Automation and Public packages for the owner to choose from. Amadeus and Tangu include local runtimes. Source manifests in `unit/plugins` are frontend declarations, not complete local runtime packages.
+
+默认仅监听回环地址。设备所有者密钥保存在私有数据目录；访问链接用 fragment 传递密钥，网页消费后移除，仅保留在当前标签会话。实例数据目录应在发行目录外，更新代码不会覆盖数据。`init` 拒绝覆盖已有配置。
+
+The default listener is loopback-only. The owner key stays in private instance data; the browser consumes it from the URL fragment, removes it and retains it only for that tab session. Keep instance data outside the release directory so code updates preserve data. `init` refuses to overwrite existing configuration.
+
+## 插件与生命周期 / Plugins and lifecycle
+
+```sh
+node main.mjs status /absolute/path/my-unit/unit.json
+node main.mjs disable /absolute/path/my-unit/unit.json calendar
+node main.mjs enable /absolute/path/my-unit/unit.json calendar
+node main.mjs restart /absolute/path/my-unit/unit.json tangu
+node main.mjs install /absolute/path/my-unit/unit.json /absolute/path/new-plugin-package
+```
+
+相同 ID 的新包是更新；已运行的插件可在线替换，激活失败恢复旧版本。依赖按顺序启停，不能先停用仍被其他活跃插件依赖的包。安装全新插件前停止 Unit。迁移命令 `migrate <config> <plugin-id>` 仅用于提供迁移能力且未激活的插件。控制通道仅对本机所有者开放，独立于网页访问者。
+
+Installing a new package with the same ID updates it. Running plugins can be replaced live, with rollback on activation failure. Dependencies determine lifecycle order; a dependency cannot be disabled while its dependents are active. Stop Unit before adding a new plugin. `migrate <config> <plugin-id>` applies only to inactive plugins that provide migrations. The local owner control channel is separate from browser visitor access.
+
+插件继续使用 Forsion 的 `main`、Space 配方和插件 API。可选 `frontend.features` 激活共享界面中的 Amadeus、Tangu、Calendar、Automation、Public 功能；新增界面实现仍需更新 Unit。可信插件可声明 `runtime` 提供设备能力，或声明 `backend` 提供 HTTP 服务。接口分别见 `runtimeTypes.ts` 和 `backendTypes.ts`；支持这些通用接口不代表预装任何商业实现。
+
+Plugins use Forsion's existing `main`, Space recipes and plugin API. Optional `frontend.features` activates Amadeus, Tangu, Calendar, Automation or Public in the shared renderer; new UI implementations still require a Unit update. Trusted plugins can declare `runtime` for device capabilities or `backend` for HTTP services, as defined in `runtimeTypes.ts` and `backendTypes.ts`. Supporting these generic contracts does not bundle a commercial implementation.
+
+Unit 拥有投射端口，后端插件通过 worker 和进程内流接入；Tangu 的本地引擎由插件单独托管。未安装对应插件时不创建业务笔记库或启动引擎。账号身份可由外部插件提供，浏览器访问者的配置与插件数据按已验证身份隔离。公开投射与本地所有者模式必须显式选择，服务不可用不会回落到设备数据。
+
+Unit owns the projection port and dispatches backend plugin requests through workers and in-process streams. The Tangu plugin manages its own local engine. Without the relevant plugin, Unit creates no business vault or engine. External plugins may provide account identities; visitor preferences and plugin data are scoped to verified identities. Public projection and local owner mode are explicit choices; service failure never falls back to device data.
+
+本地运行时和后端插件采用可信代码模型，具有宿主用户权限；worker 提供生命周期隔离，不提供恶意代码沙箱。本地 Tangu 可使用直接配置的模型供应商，无需商业 Server；生成内容仍需要可用模型。
+
+Local runtimes and backend plugins are trusted code with the host user's permissions. Workers isolate lifecycle, not malicious code. Local Tangu can use directly configured model providers without the commercial Server; generation still requires an available model.
+
+## 验证 / Verification
+
+```sh
+node unit/check-sync.mjs
+node --test unit/*.test.mjs
+cd desktop
+npm run typecheck
+npm run check:parity
+npx vitest run electron/unit*.test.ts electron/backendRunner.test.ts electron/basicUnit.test.ts
+```
+
+`node unit/verify-local.mjs --qbird /absolute/path/bluebird` 使用已构建的发行包，在临时目录验证安装、真实本地笔记、插件和引擎生命周期、重启持久化；不需要商业后端或数据库。`--serve` 可保留独立预览。必须使用与发行包原生模块匹配的 Node；构建时可用 `UNIT_SQLITE_PACKAGE` 指向同版本、目标 ABI 的 SQLite 包。
+
+`node unit/verify-local.mjs --qbird /absolute/path/bluebird` verifies the built release in a temporary directory, including installation, real local notes, plugin and engine lifecycle, and restart persistence. It needs no commercial backend or database. `--serve` retains an isolated preview. Use a Node runtime matching the package's native modules; `UNIT_SQLITE_PACKAGE` can select the same locked SQLite version built for the target ABI.

package/backendWorker.mjs

@@ -0,0 +1,273 @@
+// unit/backendWorker.ts
+import http from "node:http";
+import net from "node:net";
+import { pathToFileURL } from "node:url";
+import { format } from "node:util";
+import { parentPort, workerData } from "node:worker_threads";
+
+// unit/portDuplex.ts
+import { Duplex } from "node:stream";
+var PortDuplex = class extends Duplex {
+  constructor(port, metadata = {}, options = {}) {
+    super({ allowHalfOpen: true, ...options });
+    this.port = port;
+    Object.assign(this, metadata);
+    this.on("error", () => {
+    });
+    port.on("message", (packet) => {
+      if (this.destroyed) return;
+      this.touch();
+      if (packet.type === "data") {
+        if (this.push(Buffer.from(packet.bytes))) this.send({ type: "ack" });
+        else this.awaitingRead = true;
+      } else if (packet.type === "ack") {
+        const callback = this.pendingWrite;
+        this.pendingWrite = void 0;
+        callback?.();
+      } else if (packet.type === "end") {
+        this.receivedEnd = true;
+        this.push(null);
+      } else if (packet.type === "close") {
+        this.destroy();
+      }
+    });
+    port.on("messageerror", () => this.destroy(new Error("Invalid backend connection message")));
+    port.on("close", () => {
+      if (!this.destroyed) this.destroy(this.receivedEnd ? void 0 : new Error("Backend connection closed"));
+    });
+  }
+  connecting = false;
+  pending = false;
+  remoteAddress;
+  remotePort;
+  remoteFamily;
+  localAddress;
+  localPort;
+  encrypted;
+  pendingWrite;
+  awaitingRead = false;
+  receivedEnd = false;
+  timeoutMs = 0;
+  timeoutTimer;
+  send(packet) {
+    try {
+      this.port.postMessage(packet);
+    } catch {
+      this.destroy(new Error("Backend connection unavailable"));
+    }
+  }
+  touch() {
+    if (!this.timeoutMs) return;
+    if (this.timeoutTimer) clearTimeout(this.timeoutTimer);
+    this.timeoutTimer = setTimeout(() => this.emit("timeout"), this.timeoutMs);
+    this.timeoutTimer.unref();
+  }
+  _read() {
+    if (this.awaitingRead) {
+      this.awaitingRead = false;
+      this.send({ type: "ack" });
+    }
+  }
+  _write(chunk, encoding, callback) {
+    this.touch();
+    this.pendingWrite = callback;
+    this.send({ type: "data", bytes: typeof chunk === "string" ? Buffer.from(chunk, encoding) : chunk });
+  }
+  _final(callback) {
+    this.send({ type: "end" });
+    callback();
+  }
+  _destroy(error, callback) {
+    if (this.timeoutTimer) clearTimeout(this.timeoutTimer);
+    const pending = this.pendingWrite;
+    this.pendingWrite = void 0;
+    pending?.(error ?? new Error("Backend connection closed"));
+    try {
+      this.port.postMessage({ type: "close" });
+    } catch {
+    }
+    this.port.close();
+    callback(error);
+  }
+  setTimeout(milliseconds, callback) {
+    if (callback) this.once("timeout", callback);
+    this.timeoutMs = milliseconds;
+    if (this.timeoutTimer) clearTimeout(this.timeoutTimer);
+    this.timeoutTimer = void 0;
+    this.touch();
+    return this;
+  }
+  setNoDelay() {
+    return this;
+  }
+  setKeepAlive() {
+    return this;
+  }
+  ref() {
+    this.port.ref();
+    return this;
+  }
+  unref() {
+    this.port.unref();
+    this.timeoutTimer?.unref();
+    return this;
+  }
+  address() {
+    return { address: this.localAddress ?? "", family: this.remoteFamily ?? "IPv4", port: this.localPort ?? 0 };
+  }
+};
+
+// unit/backendWorker.ts
+if (!parentPort) throw new Error("Backend worker requires a parent Unit");
+var parent = parentPort;
+var data = workerData;
+var controller = new AbortController();
+var connections = /* @__PURE__ */ new Set();
+var accountCalls = /* @__PURE__ */ new Map();
+var plugin;
+var server;
+var stopping;
+var creating;
+var activeHook;
+var ready = false;
+net.Server.prototype.listen = function() {
+  throw new Error("Backend plugins must use the Unit HTTP listener");
+};
+function send(event) {
+  parent.postMessage(event);
+}
+async function shutdown() {
+  if (stopping) return stopping;
+  stopping = (async () => {
+    ready = false;
+    controller.abort();
+    for (const call of accountCalls.values()) call.abort();
+    for (const connection of connections) connection.destroy();
+    connections.clear();
+    server?.closeAllConnections();
+    await new Promise((resolve) => setImmediate(resolve));
+    await creating?.catch(() => {
+    });
+    try {
+      await plugin?.stop?.();
+    } finally {
+      await activeHook?.catch(() => {
+      });
+    }
+  })();
+  return stopping;
+}
+async function fail(error) {
+  const cause = error instanceof Error ? error : new Error(String(error));
+  try {
+    await shutdown();
+  } catch {
+  }
+  send({ type: "failure", message: cause.message, stack: cause.stack });
+}
+parent.on("message", (command) => {
+  if (command.type === "stop") {
+    void shutdown().then(() => send({ type: "stopped" }), fail);
+    return;
+  }
+  if (command.type === "account-cancel") {
+    accountCalls.get(command.requestId)?.abort();
+    return;
+  }
+  if (command.type === "account-resolve") {
+    void resolveAccount(command);
+    return;
+  }
+  if (command.type !== "connection") return;
+  if (!ready || !server) {
+    command.port.close();
+    return;
+  }
+  const connection = new PortDuplex(command.port, command.socket);
+  connections.add(connection);
+  connection.once("close", () => connections.delete(connection));
+  server.emit("connection", connection);
+});
+function identityFields(value) {
+  if (value === null) return null;
+  if (!value || typeof value !== "object") throw new Error("Invalid account identity");
+  const identity = {};
+  for (const field of ["userId", "username", "role", "tenantId", "workspaceId", "nickname", "avatar"]) {
+    const input = value[field];
+    if (input === void 0 && !["userId", "username", "role"].includes(field)) continue;
+    const limit = field === "avatar" ? 1024 * 1024 : 512;
+    if (typeof input !== "string" || input.length > limit || /[\x00-\x1f\x7f]/.test(input) || ["userId", "username", "role", "tenantId", "workspaceId"].includes(field) && !input.trim()) {
+      throw new Error("Invalid account identity");
+    }
+    identity[field] = input;
+  }
+  return identity;
+}
+async function resolveAccount(command) {
+  if (!ready || !plugin?.account || accountCalls.size >= 256 || accountCalls.has(command.requestId) || typeof command.token !== "string" || !command.token || command.token.length > 16384) {
+    send({ type: "account-error", requestId: command.requestId });
+    return;
+  }
+  const call = new AbortController();
+  accountCalls.set(command.requestId, call);
+  try {
+    const result = await plugin.account.resolve(command.token, { signal: call.signal });
+    if (!call.signal.aborted && ready) send({ type: "account-result", requestId: command.requestId, identity: identityFields(result) });
+  } catch {
+    if (!call.signal.aborted && ready) send({ type: "account-error", requestId: command.requestId });
+  } finally {
+    accountCalls.delete(command.requestId);
+  }
+}
+async function boot() {
+  const entry = await import(pathToFileURL(data.entry).href);
+  if (controller.signal.aborted) return;
+  const factory = entry.default;
+  if (typeof factory !== "function") throw new Error("Backend entry must default-export a factory");
+  creating = (async () => {
+    plugin = await factory({
+      packageDir: data.packageDir,
+      dataDir: data.dataDir,
+      config: data.config,
+      signal: controller.signal,
+      log: (...messages) => send({ type: "log", message: format(...messages) }),
+      requestRestart: () => send({ type: "restart" })
+    });
+  })();
+  await creating;
+  if (controller.signal.aborted) return;
+  if (!plugin || typeof plugin.handle !== "function" || !Array.isArray(plugin.mounts) || plugin.mounts.some((mount) => typeof mount !== "string" || !mount.startsWith("/") || /[?#\r\n]/.test(mount))) {
+    throw new Error("Backend factory must provide a handler and absolute mounts");
+  }
+  if (plugin.account !== void 0 && typeof plugin.account?.resolve !== "function") {
+    throw new Error("Backend account provider must provide resolve");
+  }
+  const metadata = plugin.account?.metadata;
+  if (metadata && [metadata.apiBase, metadata.loginPath].some((value) => typeof value !== "string" || !value.startsWith("/") || value.startsWith("//") || /[\\\s?#]/.test(value) || value.split("/").some((part) => part === "." || part === ".."))) {
+    throw new Error("Account endpoints must be absolute same-origin paths");
+  }
+  if (data.mode === "migrate") {
+    activeHook = Promise.resolve().then(() => plugin.migrate?.());
+    await activeHook;
+    if (controller.signal.aborted) return;
+    await shutdown();
+    send({ type: "migrated" });
+    return;
+  }
+  activeHook = Promise.resolve().then(() => plugin.start?.());
+  await activeHook;
+  if (controller.signal.aborted) return;
+  server = http.createServer(plugin.handle);
+  if (plugin.upgrade) server.on("upgrade", plugin.upgrade);
+  server.requestTimeout = 0;
+  server.headersTimeout = 0;
+  server.timeout = 0;
+  ready = true;
+  send({
+    type: "ready",
+    mounts: plugin.mounts,
+    hasAccount: Boolean(plugin.account),
+    accountMetadata: metadata ? { apiBase: metadata.apiBase, loginPath: metadata.loginPath } : void 0
+  });
+}
+void boot().catch(fail);