Slice 1: surface system + WS transport + composition root

Pure-core feature libraries assembled at the composition root:
- core/protocol: pure reducer over surface catalog/spec/error messages
- features/surface-host: generic field-kind interpreter (toggle/progress/
  selector/stat/button) + pure plan logic; no surface-id special-casing
- adapters/ws: injected WebSocket client (effects at the edge)
- app: composition root store (Svelte 5 runes over the pure reducer),
  host-relative surface WS URL resolution (resolveWsUrl), root App.svelte

Verified green: svelte-check 0/0, vitest 84 passed, biome clean, vite build ok.

1 files changed, 195 insertions, 0 deletions

diff --git a/src/adapters/ws/logic.test.ts b/src/adapters/ws/logic.test.ts
new file mode 100644
index 0000000..62ae6a0
--- /dev/null
+++ b/src/adapters/ws/logic.test.ts
@@ -0,0 +1,195 @@
+import { describe, expect, it } from "vitest";
+import { nextBackoffMs, parseServerMessage, serialize } from "./logic";
+
+describe("serialize", () => {
+	it("serializes a subscribe message", () => {
+		const msg = { type: "subscribe" as const, surfaceId: "s1" };
+		expect(JSON.parse(serialize(msg))).toEqual(msg);
+	});
+
+	it("serializes an unsubscribe message", () => {
+		const msg = { type: "unsubscribe" as const, surfaceId: "s1" };
+		expect(JSON.parse(serialize(msg))).toEqual(msg);
+	});
+
+	it("serializes an invoke message with payload", () => {
+		const msg = { type: "invoke" as const, surfaceId: "s1", actionId: "toggle", payload: true };
+		expect(JSON.parse(serialize(msg))).toEqual(msg);
+	});
+
+	it("serializes an invoke message without payload", () => {
+		const msg = { type: "invoke" as const, surfaceId: "s1", actionId: "click" };
+		expect(JSON.parse(serialize(msg))).toEqual(msg);
+	});
+});
+
+describe("parseServerMessage", () => {
+	it("parses a catalog message", () => {
+		const data = JSON.stringify({
+			type: "catalog",
+			catalog: [{ id: "s1", region: "r", title: "S1" }],
+		});
+		const result = parseServerMessage(data);
+		expect(result).toEqual({
+			type: "catalog",
+			catalog: [{ id: "s1", region: "r", title: "S1" }],
+		});
+	});
+
+	it("parses a surface message", () => {
+		const data = JSON.stringify({
+			type: "surface",
+			spec: { id: "s1", region: "r", title: "S1", fields: [] },
+		});
+		const result = parseServerMessage(data);
+		expect(result).toEqual({
+			type: "surface",
+			spec: { id: "s1", region: "r", title: "S1", fields: [] },
+		});
+	});
+
+	it("parses an update message", () => {
+		const data = JSON.stringify({
+			type: "update",
+			update: {
+				surfaceId: "s1",
+				spec: { id: "s1", region: "r", title: "S1", fields: [] },
+			},
+		});
+		const result = parseServerMessage(data);
+		expect(result).toEqual({
+			type: "update",
+			update: {
+				surfaceId: "s1",
+				spec: { id: "s1", region: "r", title: "S1", fields: [] },
+			},
+		});
+	});
+
+	it("parses an error message with surfaceId", () => {
+		const data = JSON.stringify({ type: "error", surfaceId: "s1", message: "boom" });
+		const result = parseServerMessage(data);
+		expect(result).toEqual({ type: "error", surfaceId: "s1", message: "boom" });
+	});
+
+	it("parses an error message without surfaceId", () => {
+		const data = JSON.stringify({ type: "error", message: "global boom" });
+		const result = parseServerMessage(data);
+		expect(result).toEqual({ type: "error", message: "global boom" });
+	});
+
+	it("returns null for malformed JSON", () => {
+		expect(parseServerMessage("not json")).toBeNull();
+		expect(parseServerMessage("{broken")).toBeNull();
+		expect(parseServerMessage("")).toBeNull();
+	});
+
+	it("returns null for non-object JSON", () => {
+		expect(parseServerMessage("42")).toBeNull();
+		expect(parseServerMessage('"hello"')).toBeNull();
+		expect(parseServerMessage("null")).toBeNull();
+		expect(parseServerMessage("true")).toBeNull();
+		expect(parseServerMessage("[1,2,3]")).toBeNull();
+	});
+
+	it("returns null for unknown type", () => {
+		expect(parseServerMessage(JSON.stringify({ type: "unknown" }))).toBeNull();
+	});
+
+	it("returns null when type is missing", () => {
+		expect(parseServerMessage(JSON.stringify({ foo: "bar" }))).toBeNull();
+	});
+
+	it("returns null when type is not a string", () => {
+		expect(parseServerMessage(JSON.stringify({ type: 42 }))).toBeNull();
+	});
+
+	it("returns null for catalog with non-array catalog field", () => {
+		expect(parseServerMessage(JSON.stringify({ type: "catalog", catalog: "nope" }))).toBeNull();
+	});
+
+	it("returns null for surface with missing spec fields", () => {
+		expect(parseServerMessage(JSON.stringify({ type: "surface", spec: { id: "s1" } }))).toBeNull();
+	});
+
+	it("returns null for surface with non-object spec", () => {
+		expect(parseServerMessage(JSON.stringify({ type: "surface", spec: "nope" }))).toBeNull();
+	});
+
+	it("returns null for update with missing update field", () => {
+		expect(parseServerMessage(JSON.stringify({ type: "update" }))).toBeNull();
+	});
+
+	it("returns null for update with invalid spec", () => {
+		expect(
+			parseServerMessage(JSON.stringify({ type: "update", update: { surfaceId: "s1", spec: {} } })),
+		).toBeNull();
+	});
+
+	it("returns null for error with non-string message", () => {
+		expect(parseServerMessage(JSON.stringify({ type: "error", message: 42 }))).toBeNull();
+	});
+
+	it("returns null for error with invalid surfaceId type", () => {
+		expect(
+			parseServerMessage(JSON.stringify({ type: "error", surfaceId: 42, message: "boom" })),
+		).toBeNull();
+	});
+});
+
+describe("round-trip: parseServerMessage(serialize(...))", () => {
+	it("round-trips a subscribe message through serialize only", () => {
+		const msg = { type: "subscribe" as const, surfaceId: "s1" };
+		const wire = serialize(msg);
+		expect(JSON.parse(wire)).toEqual(msg);
+	});
+
+	it("round-trips an invoke message with payload", () => {
+		const msg = { type: "invoke" as const, surfaceId: "s1", actionId: "toggle", payload: false };
+		const wire = serialize(msg);
+		expect(JSON.parse(wire)).toEqual(msg);
+	});
+});
+
+describe("nextBackoffMs", () => {
+	it("returns a positive number", () => {
+		expect(nextBackoffMs(0)).toBeGreaterThan(0);
+	});
+
+	it("is capped at 30s + jitter (at most ~36s)", () => {
+		for (let i = 0; i < 100; i++) {
+			expect(nextBackoffMs(100)).toBeLessThanOrEqual(36_000);
+		}
+	});
+
+	it("starts around 500ms (±20% jitter)", () => {
+		for (let i = 0; i < 100; i++) {
+			const ms = nextBackoffMs(0);
+			expect(ms).toBeGreaterThanOrEqual(400);
+			expect(ms).toBeLessThanOrEqual(600);
+		}
+	});
+
+	it("grows exponentially with attempt", () => {
+		const averages = [0, 1, 2, 3].map((attempt) => {
+			let sum = 0;
+			for (let i = 0; i < 200; i++) {
+				sum += nextBackoffMs(attempt);
+			}
+			return sum / 200;
+		});
+		for (let i = 1; i < averages.length; i++) {
+			const prev = averages[i - 1];
+			if (prev === undefined) throw new Error("unreachable");
+			expect(averages[i]).toBeGreaterThan(prev);
+		}
+	});
+
+	it("treats negative attempt as 0", () => {
+		for (let i = 0; i < 50; i++) {
+			const ms = nextBackoffMs(-5);
+			expect(ms).toBeGreaterThanOrEqual(400);
+			expect(ms).toBeLessThanOrEqual(600);
+		}
+	});
+});