sailfork / t3code-github / .repos/ alchemy-effect/ packages/ integration-tests/ test/ Cloudflare/ Workers/ RpcWebSocket.test.ts

import * as Cloudflare from "@alchemy.run/cloudflare";
import * as RpcWebSocketClient from "@alchemy.run/cloudflare/Workers/RpcWebSocketClient";
import { describe, expect } from "@alchemy.run/test";
import * as Test from "@alchemy.run/test/Alchemy";
import * as Alchemy from "alchemy";
import type { Done, TimeoutError } from "effect/Cause";
import * as Context from "effect/Context";
import * as Data from "effect/Data";
import * as Deferred from "effect/Deferred";
import * as Effect from "effect/Effect";
import * as Exit from "effect/Exit";
import * as Fiber from "effect/Fiber";
import * as HttpClientRequest from "effect/http/HttpClientRequest";
import * as Layer from "effect/Layer";
import * as ManagedRuntime from "effect/ManagedRuntime";
import * as Queue from "effect/Queue";
import { RpcClient, RpcSerialization } from "effect/rpc";
import type { RpcClientError } from "effect/rpc/RpcClientError";
import * as Schedule from "effect/Schedule";
import * as Schema from "effect/Schema";
import * as Scope from "effect/Scope";
import * as Socket from "effect/socket/Socket";
import * as Stream from "effect/Stream";
import { requestWorker, waitUntilStable } from "../Utils/WorkerRequest.ts";
import { Greeting, Rejected, SocketRpcs, SocketStats } from "./fixtures/rpc-websocket/rpcs.ts";
import SocketWorker from "./fixtures/rpc-websocket/worker.ts";

class SocketClient extends Context.Service<SocketClient>()("SocketClient", {
  make: RpcClient.make(SocketRpcs),
}) {}

const observeSockets = Effect.sync(() => {
  const sockets: {
    socket: WebSocket;
    closeCodes: (number | undefined)[];
    closed: Deferred.Deferred<{ code: number; reason: string }>;
  }[] = [];
  const constructor = (url: string) =>
    Layer.effect(
      Socket.WebSocketConstructor,
      Effect.gen(function* () {
        // Retry only the native handshake, before constructing the RPC client.
        const { socket: ready } = yield* rawConnect(url);
        let consumed = false;
        return (url: string) => {
          const socket = consumed ? new WebSocket(url) : ready;
          consumed = true;
          const closeCodes: (number | undefined)[] = [];
          const close = socket.close.bind(socket);
          socket.close = (code, reason) => {
            closeCodes.push(code);
            close(code, reason);
          };
          const closed = Deferred.makeUnsafe<{ code: number; reason: string }>();
          socket.addEventListener("close", (event) =>
            Deferred.doneUnsafe(closed, Exit.succeed({ code: event.code, reason: event.reason })),
          );
          sockets.push({ socket, closeCodes, closed });
          return socket;
        };
      }),
    );
  return {
    sockets,
    layer: (url: string) =>
      RpcWebSocketClient.layer(SocketClient, SocketRpcs, url.replace(/^http/, "ws"), {
        protocol: { retryTransientErrors: false },
      }).pipe(Layer.provide(constructor(url))),
    assertClosed: Effect.gen(function* () {
      expect(sockets).toHaveLength(1);
      const { socket, closeCodes, closed } = sockets[0]!;
      // The RPC Layer must close before rawConnect's fallback finalizer.
      expect(closeCodes[0]).toBe(1000);
      expect((yield* Deferred.await(closed).pipe(Effect.timeout("10 seconds"))).code).toBe(1000);
      expect(socket.readyState).toBe(WebSocket.CLOSED);
      expect(sockets).toHaveLength(1);
    }),
  };
});

const connect = Effect.fn(function* (url: string) {
  const { socket: raw } = yield* rawConnect(url);
  const protocol = RpcClient.layerProtocolSocket().pipe(
    Layer.provide(
      Layer.mergeAll(
        Layer.effect(Socket.Socket, Socket.fromWebSocket(Effect.succeed(raw))),
        RpcSerialization.layerJson,
      ),
    ),
  );
  const context = yield* Layer.build(protocol);
  const client = yield* RpcClient.make(SocketRpcs).pipe(Effect.provide(context));
  return { client, raw };
});

class WebSocketHandshakeFailed extends Data.TaggedError("WebSocketHandshakeFailed")<{
  readonly message: string;
}> {}

type ClientLayerError = RpcClientError | WebSocketHandshakeFailed | TimeoutError;

const rawConnect = Effect.fn(
  function* (url: string) {
    const opened = yield* Deferred.make<void, WebSocketHandshakeFailed>();
    const closed = yield* Deferred.make<{ code: number; reason: string }>();
    const messages = yield* Queue.unbounded<string>();
    const socket = yield* Effect.acquireRelease(
      Effect.sync(() => {
        const socket = new WebSocket(url.replace(/^http/, "ws"));
        socket.addEventListener("open", () => Deferred.doneUnsafe(opened, Exit.void));
        socket.addEventListener("error", (event) =>
          Deferred.doneUnsafe(
            opened,
            Exit.fail(
              new WebSocketHandshakeFailed({
                message: `WebSocket handshake failed: ${"message" in event ? event.message : event.type}`,
              }),
            ),
          ),
        );
        socket.addEventListener("message", (event) =>
          Queue.offerUnsafe(messages, String(event.data)),
        );
        socket.addEventListener("close", (event) =>
          Deferred.doneUnsafe(closed, Exit.succeed({ code: event.code, reason: event.reason })),
        );
        return socket;
      }),
      (socket) => Effect.sync(() => socket.close()),
    );
    yield* Deferred.await(opened).pipe(
      Effect.timeout("10 seconds"),
      Effect.onError(() => Effect.sync(() => socket.close())),
    );
    const send = (value: unknown) => Effect.sync(() => socket.send(JSON.stringify(value)));
    const receive = Queue.take(messages).pipe(
      Effect.flatMap((value) => Effect.try(() => JSON.parse(value))),
      Effect.timeout("10 seconds"),
    );
    return {
      socket,
      send,
      receive,
      buffered: Queue.size(messages),
      closed: Deferred.await(closed).pipe(Effect.timeout("10 seconds")),
    };
  },
  Effect.retry({
    // Bun hides rejected upgrade responses; retry only before any RPC is sent.
    while: (error) => error._tag === "WebSocketHandshakeFailed",
    schedule: Schedule.spaced("1 second"),
    times: 8,
  }),
);

/**
 * Name Durable Objects per test attempt. The deployed Worker is shared across
 * runner retries, so a fixed name would reuse an activation whose in-memory
 * `opened`/`closed`/`cleanupStarted` state an earlier attempt already filled.
 */
const freshObjects = Effect.sync(() => {
  const suffix = crypto.randomUUID();
  return (name: string) => `${name}-${suffix}`;
});

const readStats = Effect.fn(function* (url: string) {
  const response = yield* requestWorker(HttpClientRequest.get(url));
  if (response.status !== 200) {
    return yield* Effect.fail(new Error(`GET ${url}: ${response.status}: ${yield* response.text}`));
  }
  return yield* response.json.pipe(Effect.flatMap(Schema.decodeUnknownEffect(SocketStats)));
}, Effect.timeout("15 seconds"));

describe.concurrent.each([
  { dev: true, stage: `${Test.defaultStage()}-rpc-websocket-local` },
  { dev: false, stage: `${Test.defaultStage()}-rpc-websocket-live` },
])(
  "WebSocket RPC (dev: $dev)",
  ({ dev, stage }) => {
    const state = dev ? Alchemy.inMemoryState() : Cloudflare.state();
    const Stack = Alchemy.Stack(
      "RpcWebSocketStack",
      { providers: Cloudflare.providers(), state },
      Effect.gen(function* () {
        const worker = yield* SocketWorker;
        return { url: worker.url.as<string>() };
      }),
    );
    const { test, beforeAll, afterAll, deploy, destroy } = Test.make({
      providers: Cloudflare.providers(),
      state,
      dev,
      stage,
    });
    const stack = beforeAll(
      Effect.gen(function* () {
        yield* destroy(Stack);
        const output = yield* deploy(Stack);
        // A new version reaches Cloudflare's hosts one at a time; hosts still
        // on the old version reject the upgrade ("Expected 101"). Require the
        // HTTP route and a handshake to succeed several times in a row.
        yield* waitUntilStable(
          `RPC WebSocket worker at ${output.url}`,
          requestWorker(HttpClientRequest.get(`${output.url}/ready`)).pipe(
            Effect.flatMap((response) =>
              response.text.pipe(
                Effect.flatMap((body) =>
                  response.status === 200 && body === "ready"
                    ? Effect.void
                    : Effect.fail(new Test.WorkerNotReady({ status: response.status })),
                ),
              ),
            ),
            Effect.andThen(rawConnect(`${output.url}/rpc/ready`).pipe(Effect.scoped)),
            Effect.as(true),
            Effect.catchTag(["WorkerNotPropagated", "WebSocketHandshakeFailed"], () =>
              Effect.succeed(false),
            ),
          ),
        );
        return output;
      }),
      { timeout: 180_000 },
    );
    afterAll.skipIf(!!process.env.NO_DESTROY)(destroy(Stack), { timeout: 30_000 });

    test(
      "readiness handling preserves application HTTP errors",
      Effect.gen(function* () {
        const { url } = yield* stack;
        for (const [path, status] of [
          ["not-found", 404],
          ["server-error", 500],
        ] as const) {
          const response = yield* requestWorker(HttpClientRequest.get(`${url}/${path}`));
          expect(response.status).toBe(status);
          expect(yield* response.text).toBe("application error");
        }
      }).pipe(Effect.scoped),
      { tags: [...(dev ? ["local"] : ["live"])], timeout: 30_000 },
    );

    test(
      "typed unary, failure, streaming, and HTTP clients share one object",
      Effect.gen(function* () {
        const { url } = yield* stack;
        const object = yield* freshObjects;
        const { client } = yield* connect(`${url}/rpc/${object("roundtrip")}`);
        const greeting = yield* client.greet({ name: "Sam" });
        expect(greeting).toBeInstanceOf(Greeting);
        expect(greeting.message).toBe("Hello, Sam!");
        expect(yield* client.increment()).toBe(1);
        expect(yield* client.reject().pipe(Effect.flip)).toBeInstanceOf(Rejected);
        expect(yield* client.numbers({ count: 40 }).pipe(Stream.runCollect)).toEqual(
          Array.from({ length: 40 }, (_, i) => i + 1),
        );
        const response = yield* requestWorker(
          HttpClientRequest.get(`${url}/stats/${object("roundtrip")}`),
        );
        expect(response.status).toBe(200);
        expect(yield* response.json).toMatchObject({ count: 1 });
      }).pipe(Effect.scoped),
      { tags: [...(dev ? ["local"] : ["live"])], timeout: 30_000 },
    );

    test(
      "a Layer shares one actual socket for concurrent callers without a caller scope and closes normally",
      Effect.gen(function* () {
        const { url } = yield* stack;
        const object = yield* freshObjects;
        const endpoint = `${url}/rpc/${object("layer-client")}`;
        const observed = yield* observeSockets;
        const program: Effect.Effect<readonly number[], ClientLayerError> = Effect.gen(
          function* () {
            const results = yield* Effect.all(
              Array.from({ length: 40 }, () =>
                Effect.gen(function* () {
                  const client = yield* SocketClient;
                  return yield* client.increment();
                }),
              ),
              { concurrency: "unbounded" },
            );
            const client = yield* SocketClient;
            expect(yield* client.numbers({ count: 3 }).pipe(Stream.runCollect)).toEqual([1, 2, 3]);
            expect(observed.sockets).toHaveLength(1);
            expect(observed.sockets[0]!.socket.readyState).toBe(WebSocket.OPEN);
            return results;
          },
        ).pipe(Effect.provide(observed.layer(endpoint)));
        expect((yield* program).toSorted((a, b) => a - b)).toEqual(
          Array.from({ length: 40 }, (_, i) => i + 1),
        );
        yield* observed.assertClosed;
        expect((yield* readStats(`${url}/stats/${object("layer-client")}`)).count).toBe(40);
      }),
      { tags: [...(dev ? ["local"] : ["live"])], timeout: 30_000 },
    );

    test(
      "a Layer closes its actual socket with code 1000 on application failure",
      Effect.gen(function* () {
        const { url } = yield* stack;
        const object = yield* freshObjects;
        const endpoint = `${url}/rpc/${object("layer-failure")}`;
        const observed = yield* observeSockets;
        const program: Effect.Effect<never, Rejected | ClientLayerError> = Effect.gen(function* () {
          const client = yield* SocketClient;
          yield* client.increment();
          return yield* client.reject();
        }).pipe(Effect.provide(observed.layer(endpoint)));
        expect(yield* program.pipe(Effect.flip)).toBeInstanceOf(Rejected);
        yield* observed.assertClosed;
        expect((yield* readStats(`${url}/stats/${object("layer-failure")}`)).count).toBe(1);
      }),
      { tags: [...(dev ? ["local"] : ["live"])], timeout: 30_000 },
    );

    test(
      "interrupting a Layer closes its actual socket with code 1000 and releases the handler",
      Effect.gen(function* () {
        const { url } = yield* stack;
        const object = yield* freshObjects;
        const endpoint = `${url}/rpc/${object("layer-interruption")}`;
        const observed = yield* observeSockets;
        const started = yield* Deferred.make<void>();
        const program: Effect.Effect<void, ClientLayerError> = Effect.gen(function* () {
          const client = yield* SocketClient;
          yield* client
            .watch({ key: "layer-interruption" })
            .pipe(Stream.runForEach(() => Deferred.succeed(started, undefined)));
        }).pipe(Effect.provide(observed.layer(endpoint)));
        const fiber = yield* program.pipe(Effect.forkScoped);
        yield* Deferred.await(started).pipe(Effect.timeout("10 seconds"));
        expect(observed.sockets).toHaveLength(1);
        yield* Fiber.interrupt(fiber);
        expect(Exit.hasInterrupts(yield* Fiber.await(fiber))).toBe(true);
        yield* observed.assertClosed;
        const status = yield* readStats(`${url}/stats/${object("layer-interruption")}`).pipe(
          Effect.repeat({
            schedule: Schedule.spaced("250 millis"),
            times: 40,
            until: (state) => state.closed.includes("layer-interruption"),
          }),
        );
        expect(status.closed).toEqual(["layer-interruption"]);
        expect(status.invocations).toEqual({ "layer-interruption": 1 });
      }).pipe(Effect.scoped),
      { tags: [...(dev ? ["local"] : ["live"])], timeout: 30_000 },
    );

    test(
      "ManagedRuntime.dispose closes the shared actual socket with code 1000",
      Effect.gen(function* () {
        const { url } = yield* stack;
        const object = yield* freshObjects;
        const endpoint = `${url}/rpc/${object("layer-managed")}`;
        const observed = yield* observeSockets;
        const runtime = yield* Effect.acquireRelease(
          Effect.sync(() => ManagedRuntime.make(observed.layer(endpoint))),
          (runtime) => Effect.promise(() => runtime.dispose()),
        );
        const call: Effect.Effect<number, RpcClientError, SocketClient> = Effect.gen(function* () {
          const client = yield* SocketClient;
          return yield* client.increment();
        });
        const results = yield* Effect.all(
          Array.from({ length: 8 }, () =>
            Effect.sync(() => runtime.runFork(call)).pipe(Effect.flatMap(Fiber.join)),
          ),
          { concurrency: "unbounded" },
        );
        expect(results.toSorted((a, b) => a - b)).toEqual([1, 2, 3, 4, 5, 6, 7, 8]);
        expect(observed.sockets).toHaveLength(1);
        expect(observed.sockets[0]!.socket.readyState).toBe(WebSocket.OPEN);
        yield* Effect.promise(() => runtime.dispose());
        yield* observed.assertClosed;
        expect((yield* readStats(`${url}/stats/${object("layer-managed")}`)).count).toBe(8);
      }).pipe(Effect.scoped),
      { tags: [...(dev ? ["local"] : ["live"])], timeout: 30_000 },
    );

    test(
      "a queue subscription owns a separate scope without closing the Layer socket",
      Effect.gen(function* () {
        const { url } = yield* stack;
        const object = yield* freshObjects;
        const endpoint = `${url}/rpc/${object("layer-queue")}`;
        const observed = yield* observeSockets;
        const program: Effect.Effect<void, ClientLayerError | Done> = Effect.gen(function* () {
          const client = yield* SocketClient;
          yield* Effect.gen(function* () {
            const queue = yield* client.watch({ key: "queue" }, { asQueue: true });
            expect(yield* Queue.take(queue)).toBe(1);
          }).pipe(Effect.scoped);
          expect(observed.sockets).toHaveLength(1);
          expect(observed.sockets[0]!.socket.readyState).toBe(WebSocket.OPEN);
          expect((yield* client.greet({ name: "still open" })).message).toBe("Hello, still open!");
        }).pipe(Effect.provide(observed.layer(endpoint)));
        yield* program;
        yield* observed.assertClosed;
        const status = yield* readStats(`${url}/stats/${object("layer-queue")}`).pipe(
          Effect.repeat({
            schedule: Schedule.spaced("250 millis"),
            times: 40,
            until: (state) => state.closed.includes("queue"),
          }),
        );
        expect(status.closed).toEqual(["queue"]);
        expect(status.invocations).toEqual({ queue: 1 });
      }),
      { tags: [...(dev ? ["local"] : ["live"])], timeout: 30_000 },
    );

    test(
      "multiplexes concurrent calls without crossing instance state",
      Effect.gen(function* () {
        const { url } = yield* stack;
        const object = yield* freshObjects;
        const { client } = yield* connect(`${url}/rpc/${object("concurrent")}`);
        const results = yield* Effect.all(
          Array.from({ length: 40 }, () => client.increment()),
          { concurrency: "unbounded" },
        );
        expect(results.sort((a, b) => a - b)).toEqual(Array.from({ length: 40 }, (_, i) => i + 1));
        const other = yield* connect(`${url}/rpc/${object("isolated")}`);
        expect((yield* other.client.stats()).count).toBe(0);
      }).pipe(Effect.scoped),
      { tags: [...(dev ? ["local"] : ["live"])], timeout: 30_000 },
    );

    test(
      "stream interruption closes its scope and keeps the socket usable",
      Effect.gen(function* () {
        const { url } = yield* stack;
        const object = yield* freshObjects;
        const { client, raw } = yield* connect(`${url}/rpc/${object("interruption")}`);
        const scope = yield* Scope.make();
        const values = yield* client
          .watch({ key: "cancel" }, { asQueue: true })
          .pipe(Effect.provideService(Scope.Scope, scope));
        expect(yield* Queue.take(values).pipe(Effect.timeout("10 seconds"))).toBe(1);
        yield* Scope.close(scope, Exit.void);
        const status = yield* client.stats().pipe(
          Effect.repeat({
            schedule: Schedule.spaced("250 millis"),
            times: 40,
            until: (state) => state.closed.includes("cancel"),
          }),
        );
        expect(status.closed).toContain("cancel");
        expect(raw.readyState).toBe(WebSocket.OPEN);
        expect((yield* client.greet({ name: "again" })).message).toBe("Hello, again!");
      }).pipe(Effect.scoped),
      { tags: [...(dev ? ["local"] : ["live"])], timeout: 30_000 },
    );

    test(
      "socket disconnect interrupts active handler resources",
      Effect.gen(function* () {
        const { url } = yield* stack;
        const object = yield* freshObjects;
        const connection = yield* rawConnect(`${url}/rpc/${object("disconnect")}`);
        yield* connection.send({
          _tag: "Request",
          id: "1",
          tag: "watch",
          payload: { key: "disconnect" },
          headers: [],
        });
        expect(yield* connection.receive).toMatchObject({ _tag: "Chunk", values: [1] });
        yield* Effect.sync(() => connection.socket.close());
        yield* connection.closed;
        const status = yield* requestWorker(
          HttpClientRequest.get(`${url}/stats/${object("disconnect")}`),
        ).pipe(
          Effect.flatMap((response) => response.json),
          Effect.map((state) => state as { closed: string[] }),
          Effect.repeat({
            schedule: Schedule.spaced("250 millis"),
            times: 40,
            until: (state) => state.closed.includes("disconnect"),
          }),
        );
        expect(status).toMatchObject({ opened: ["disconnect"], closed: ["disconnect"] });
      }).pipe(Effect.scoped),
      { tags: [...(dev ? ["local"] : ["live"])], timeout: 30_000 },
    );

    for (const mode of ["unary", "disconnect"] as const) {
      test(
        mode === "unary"
          ? "unary result does not release the activation before deferred cleanup finishes"
          : "disconnect before any output retains the activation until deferred cleanup finishes",
        Effect.gen(function* () {
          const { url } = yield* stack;
          const object = yield* freshObjects;
          const name = object(`cleanup-${mode}`);
          const connection = yield* rawConnect(`${url}/rpc/${name}`);
          const before = yield* readStats(`${url}/stats/${name}`);
          yield* Effect.gen(function* () {
            yield* connection.send({
              _tag: "Request",
              id: "1",
              tag: "cleanup",
              payload: { key: mode, waitForDisconnect: mode === "disconnect" },
              headers: [],
            });
            if (mode === "unary") {
              expect(yield* connection.receive).toMatchObject({
                _tag: "Exit",
                requestId: "1",
                exit: { _tag: "Success", value: before.boots },
              });
            } else {
              const entered = yield* readStats(`${url}/stats/${name}`).pipe(
                Effect.repeat({
                  schedule: Schedule.spaced("250 millis"),
                  times: 40,
                  until: (state) => state.opened.includes(mode),
                }),
              );
              expect(entered.boots).toBe(before.boots);
              expect(entered.opened).toContain(mode);
              expect(entered.cleanupStarted).toEqual([]);
              expect(yield* connection.buffered).toBe(0);
              yield* Effect.sync(() => connection.socket.close());
              yield* connection.closed;
              expect(yield* connection.buffered).toBe(0);
            }
            const started = yield* readStats(`${url}/stats/${name}`).pipe(
              Effect.repeat({
                schedule: Schedule.spaced("250 millis"),
                times: 40,
                until: (state) => state.cleanupStarted.includes(mode),
              }),
            );
            expect(started.boots).toBe(before.boots);
            expect(started.cleanupStarted).toEqual([mode]);
            expect(started.cleanupCompleted).toEqual({});

            // Raw sockets send no heartbeats; only the test process has a timer.
            yield* Effect.sleep("20 seconds");
            const held = yield* readStats(`${url}/stats/${name}`);
            expect(held.boots).toBe(before.boots);
            expect(held.cleanupStarted).toEqual([mode]);
            expect(held.cleanupCompleted).toEqual({});

            if (mode === "unary") {
              expect(connection.socket.readyState).toBe(WebSocket.OPEN);
              const control = yield* rawConnect(`${url}/rpc/${name}`);
              yield* control.send({
                _tag: "Request",
                id: "1",
                tag: "releaseCleanup",
                payload: { key: mode },
                headers: [],
              });
              expect(yield* control.receive).toMatchObject({
                _tag: "Exit",
                requestId: "1",
                exit: { _tag: "Success", value: true },
              });
            } else {
              const response = yield* requestWorker(
                HttpClientRequest.post(`${url}/release/${name}/${mode}`),
              );
              expect(response.status).toBe(200);
              expect(yield* response.json).toEqual({ released: true });
            }
            const completed = yield* readStats(`${url}/stats/${name}`).pipe(
              Effect.repeat({
                schedule: Schedule.spaced("250 millis"),
                times: 40,
                until: (state) => state.cleanupCompleted[mode] !== undefined,
              }),
            );
            expect(completed.boots).toBe(before.boots);
            expect(completed.cleanupCompleted).toEqual({ [mode]: before.boots });
          }).pipe(
            Effect.ensuring(
              requestWorker(HttpClientRequest.post(`${url}/release/${name}/${mode}`)).pipe(
                Effect.timeout("15 seconds"),
                Effect.ignoreCause,
              ),
            ),
          );
        }).pipe(Effect.scoped),
        { tags: [...(dev ? ["local"] : ["live"])], timeout: 90_000 },
      );
    }

    test(
      "the same Layer-owned socket survives real hibernation and serves a new RPC",
      Effect.gen(function* () {
        const { url } = yield* stack;
        const object = yield* freshObjects;
        const endpoint = `${url}/rpc/${object("idle")}`;
        const observed = yield* observeSockets;
        yield* Effect.gen(function* () {
          const client = yield* SocketClient;
          const before = yield* client.stats();
          expect(observed.sockets).toHaveLength(1);
          const socket = observed.sockets[0]!.socket;
          const after = yield* Effect.gen(function* () {
            yield* Effect.sleep("15 seconds");
            return yield* client.stats().pipe(Effect.timeout("5 seconds"));
          }).pipe(Effect.repeat({ times: 2, until: (state) => state.boots > before.boots }));
          expect(after.boots).toBeGreaterThan(before.boots);
          expect(socket.readyState).toBe(WebSocket.OPEN);
          expect((yield* client.greet({ name: "awake" })).message).toBe("Hello, awake!");
          expect((yield* client.stats()).boots).toBe(after.boots);
          expect(observed.sockets).toHaveLength(1);
          expect(observed.sockets[0]!.socket).toBe(socket);
        }).pipe(Effect.provide(observed.layer(endpoint)));
        yield* observed.assertClosed;
      }),
      { tags: [...(dev ? ["local"] : ["live"])], timeout: 110_000 },
    );

    test(
      "hibernation resets an actual socket with an incompatible serializer attachment",
      Effect.gen(function* () {
        const { url } = yield* stack;
        const object = yield* freshObjects;
        const connection = yield* rawConnect(`${url}/rpc/${object("serialization-reset")}`);
        const before = yield* readStats(`${url}/stats/${object("serialization-reset")}`);
        const response = yield* requestWorker(
          HttpClientRequest.post(`${url}/serialization/${object("serialization-reset")}`),
        );
        expect(response.status).toBe(200);
        expect(yield* response.json).toEqual({ changed: 1 });
        expect(connection.socket.readyState).toBe(WebSocket.OPEN);
        const after = yield* Effect.gen(function* () {
          yield* Effect.sleep("15 seconds");
          return yield* readStats(`${url}/stats/${object("serialization-reset")}`);
        }).pipe(Effect.repeat({ times: 2, until: (state) => state.boots > before.boots }));
        expect(after.boots).toBeGreaterThan(before.boots);
        expect(yield* connection.closed).toEqual({
          code: 1012,
          reason: "Durable Object RPC activation reset",
        });
        expect(connection.socket.readyState).toBe(WebSocket.CLOSED);
        expect(yield* connection.buffered).toBe(0);
        const replacement = yield* connect(`${url}/rpc/${object("serialization-reset")}`);
        expect((yield* replacement.client.greet({ name: "compatible" })).message).toBe(
          "Hello, compatible!",
        );
        expect((yield* replacement.client.stats()).boots).toBe(after.boots);
      }).pipe(Effect.scoped),
      { tags: [...(dev ? ["local"] : ["live"])], timeout: 110_000 },
    );

    test(
      "native abort fails an active stream without replaying its request",
      Effect.gen(function* () {
        const { url } = yield* stack;
        const object = yield* freshObjects;
        const connection = yield* rawConnect(`${url}/rpc/${object("lost-stream")}`);
        yield* connection.send({
          _tag: "Request",
          id: "1",
          tag: "watch",
          payload: { key: "lost" },
          headers: [],
        });
        expect(yield* connection.receive).toMatchObject({ _tag: "Chunk", values: [1] });
        yield* connection.send({ _tag: "Ack", requestId: "1" });
        const before = yield* readStats(`${url}/stats/${object("lost-stream")}`);
        expect(before.invocations).toEqual({ lost: 1 });
        expect(before.opened).toEqual(["lost"]);
        const response = yield* requestWorker(
          HttpClientRequest.post(`${url}/abort/${object("lost-stream")}`),
        ).pipe(Effect.timeout("15 seconds"));
        expect(response.status).toBe(200);
        expect(yield* response.json).toEqual({ aborted: true });
        yield* connection.closed;
        expect(connection.socket.readyState).toBe(WebSocket.CLOSED);
        expect(yield* connection.buffered).toBe(0);

        const replacement = yield* connect(`${url}/rpc/${object("lost-stream")}`);
        const status = yield* replacement.client.stats();
        expect(status.boots).toBeGreaterThan(before.boots);
        expect(status.invocations).toEqual({ lost: 1 });
        expect(status.opened).toEqual([]);
        expect((yield* replacement.client.greet({ name: "reconnected" })).message).toBe(
          "Hello, reconnected!",
        );
        expect((yield* replacement.client.stats()).invocations).toEqual({ lost: 1 });
      }).pipe(Effect.scoped),
      { tags: [...(dev ? ["local"] : ["live"])], timeout: 45_000 },
    );

    test(
      "schema and unknown-method failures leave the connection usable",
      Effect.gen(function* () {
        const { url } = yield* stack;
        const object = yield* freshObjects;
        const connection = yield* rawConnect(`${url}/rpc/${object("invalid-requests")}`);
        for (const [id, tag, payload] of [
          ["1", "greet", { name: 42 }],
          ["2", "missing", {}],
        ] as const) {
          yield* connection.send({ _tag: "Request", id, tag, payload, headers: [] });
          expect(yield* connection.receive).toMatchObject({
            _tag: "Exit",
            requestId: id,
            exit: { _tag: "Failure" },
          });
        }
        yield* connection.send({
          _tag: "Request",
          id: "3",
          tag: "greet",
          payload: { name: "valid" },
          headers: [],
        });
        expect(yield* connection.receive).toMatchObject({
          _tag: "Exit",
          requestId: "3",
          exit: { _tag: "Success", value: { message: "Hello, valid!" } },
        });
      }).pipe(Effect.scoped),
      { tags: [...(dev ? ["local"] : ["live"])], timeout: 30_000 },
    );

    test(
      "malformed frames close the offending connection",
      Effect.gen(function* () {
        const { url } = yield* stack;
        const object = yield* freshObjects;
        const connection = yield* rawConnect(`${url}/rpc/${object("malformed")}`);
        yield* Effect.sync(() => connection.socket.send("not json"));
        expect((yield* connection.closed).code).toBeGreaterThanOrEqual(1002);
        const healthy = yield* connect(`${url}/rpc/${object("malformed")}`);
        expect((yield* healthy.client.greet({ name: "healthy" })).message).toBe("Hello, healthy!");
      }).pipe(Effect.scoped),
      { tags: [...(dev ? ["local"] : ["live"])], timeout: 30_000 },
    );
  },
  { tags: ["provider:cloudflare", "provider:cloudflare:worker"] },
);