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

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(", ")}`
+  );
+});