test(build): guard against merge auto-resolve damage in build-only surfaces (stream.ts + opencode-plugin) (#10318)

* fix(sse): remove duplicate sseCommentsEnabled import that breaks the production build

The #9378 merge auto-resolve left open-sse/utils/stream.ts importing
sseCommentsEnabled from sseHeartbeat.ts twice (lines 31 and 77). tsx/esbuild
(typecheck + both test runners) silently dedupe the binding, but webpack
fails the release build with "Identifier 'sseCommentsEnabled' has already
been declared" — this is the open-sse-typecheck / build base-red on
release/v3.8.50.

Adds a static regression guard (tests/unit/stream-imports-no-duplicates.test.ts,
RED on the duplicate, GREEN after) so the next merge auto-resolve of this
hot file fails in the unit suite instead of at release-build time. Also
includes the prettier canonicalization of the three style drifts the same
merge introduced (applied by lint-staged either way).

Validated: webpack release build passes on this tree (192.168.0.113 build box).

Refs #9985

* fix(opencode-plugin): remove doubled '});' that breaks the release build

The #9316 merge auto-resolve left a duplicated '});' at
@omniroute/opencode-plugin/src/index.ts:5481. The plugin is a standalone
package (outside typecheck:core and both test runners), so nothing parses
it until the release build — where tsup's DTS step fails with a cascade of
"Cannot find name" errors. The same syntax error also blocked prettier
from parsing the file, so this commit necessarily carries the prettier
pass lint-staged applies on staging (formatting was frozen since the bad
merge).

Adds tests/unit/opencode-plugin-parses.test.ts: parses every plugin source
file with the TypeScript compiler and fails on syntax diagnostics, so the
next merge-resolve accident in this uncovered package dies in the unit
suite instead of at release-build time.

Validated: release build:cli passes on the 192.168.0.113 build box with
this hotfix applied.

Refs #9985

* test(build): guard against merge auto-resolve damage in build-only surfaces

Both defects these guards cover were fixed on the base while this branch
was open, so this PR is now purely the regression guards:

- stream-imports-no-duplicates.test.ts: fails on duplicate import bindings
  in open-sse/utils/stream.ts. The #9378 merge left sseCommentsEnabled
  imported twice; tsx/esbuild dedupe it silently, so only the webpack
  release build caught it.
- opencode-plugin-parses.test.ts: parses every @omniroute/opencode-plugin
  source with the TypeScript compiler. The plugin is a standalone package
  (outside typecheck:core and both runners), so the doubled '});' from the
  #9316 merge only surfaced at tsup DTS time.

Both broke the release build on the same day, in surfaces no gate reads
until publish time. Verified failing on the pre-fix trees and passing on
the current base.

---------

Co-authored-by: Xiangzhe <bakryun0718@proton.me>

tests/unit/opencode-plugin-parses.test.ts

@@ -0,0 +1,50 @@
+/**
+ * opencode-plugin-parses.test.ts — regression guard: the opencode-plugin sources
+ * must at least PARSE as TypeScript.
+ *
+ * The plugin is a standalone package (not an npm workspace), so it is outside
+ * typecheck:core and outside both test runners — nothing parses it until the
+ * release build (prepublish → tsup dts). The #9316 merge auto-resolve left a
+ * doubled `});` in src/index.ts that broke every release build with a cascade
+ * of "Cannot find name" DTS errors. This guard makes that class of damage fail
+ * in the unit suite instead.
+ */
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFile, readdir } from "node:fs/promises";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import ts from "typescript";
+
+const PLUGIN_SRC = fileURLToPath(new URL("../../@omniroute/opencode-plugin/src", import.meta.url));
+
+test("@omniroute/opencode-plugin sources parse without syntax errors", async () => {
+  const entries = await readdir(PLUGIN_SRC, { withFileTypes: true });
+  const files = entries
+    .filter((e) => e.isFile() && e.name.endsWith(".ts"))
+    .map((e) => join(PLUGIN_SRC, e.name));
+
+  assert.ok(files.length > 0, "no plugin source files found");
+
+  const problems: string[] = [];
+  for (const file of files) {
+    const source = await readFile(file, "utf8");
+    const { diagnostics } = ts.transpileModule(source, {
+      reportDiagnostics: true,
+      compilerOptions: { target: ts.ScriptTarget.ES2022, module: ts.ModuleKind.ESNext },
+      fileName: file,
+    });
+    for (const diag of diagnostics ?? []) {
+      const where =
+        diag.file && diag.start !== undefined
+          ? diag.file.getLineAndCharacterOfPosition(diag.start)
+          : null;
+      problems.push(
+        `${file}${where ? `:${where.line + 1}:${where.character + 1}` : ""} — ` +
+          ts.flattenDiagnosticMessageText(diag.messageText, " ")
+      );
+    }
+  }
+
+  assert.deepEqual(problems, [], `syntax errors in opencode-plugin:\n${problems.join("\n")}`);
+});

tests/unit/stream-imports-no-duplicates.test.ts

@@ -0,0 +1,53 @@
+/**
+ * stream-imports-no-duplicates.test.ts — regression guard for duplicate import
+ * bindings in open-sse/utils/stream.ts.
+ *
+ * A merge auto-resolve (#9378 → commit 9a4cca4bc2) left `sseCommentsEnabled`
+ * imported twice. tsx/esbuild (typecheck + test runners) silently dedupe the
+ * binding, but the webpack production build fails with "Identifier
+ * 'sseCommentsEnabled' has already been declared" — so the defect only
+ * surfaces at release-build time. This static guard fails fast in the unit
+ * suite instead.
+ */
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+
+const STREAM_TS = fileURLToPath(new URL("../../open-sse/utils/stream.ts", import.meta.url));
+
+test("open-sse/utils/stream.ts has no duplicate import bindings", async () => {
+  const source = await readFile(STREAM_TS, "utf8");
+
+  const bindings = new Map<string, number>();
+  const importRegex = /^import\s+(?:type\s+)?(\{[\s\S]*?\}|[A-Za-z0-9_$]+)\s+from\s+/gm;
+
+  for (const match of source.matchAll(importRegex)) {
+    const clause = match[1];
+    const names = clause.startsWith("{")
+      ? clause
+          .slice(1, -1)
+          .split(",")
+          .map(
+            (n) =>
+              n
+                .trim()
+                .split(/\s+as\s+/)
+                .pop()
+                ?.trim() ?? ""
+          )
+          .filter(Boolean)
+      : [clause.trim()];
+    for (const name of names) {
+      bindings.set(name, (bindings.get(name) ?? 0) + 1);
+    }
+  }
+
+  const duplicates = [...bindings.entries()].filter(([, count]) => count > 1).map(([name]) => name);
+
+  assert.deepEqual(
+    duplicates,
+    [],
+    `duplicate import bindings in stream.ts (breaks webpack production build): ${duplicates.join(", ")}`
+  );
+});