/**
 * Additional coverage tests for edge cases in server and client shared modules
 */

import { describe, expect, test, vi } from "vitest";

import {
  createFromReadableStream,
  createServerReference,
  encodeReply,
} from "../client/shared.mjs";
import {
  createClientModuleProxy,
  createTemporaryReferenceSet,
  decodeAction,
  decodeFormState,
  decodeReply,
  decodeReplyFromAsyncIterable,
  deserializeValue,
  emitHint,
  FlightRequest,
  getCurrentRequest,
  logToConsole,
  lookupClientReference,
  lookupServerReference,
  prerender,
  registerClientReference,
  registerServerReference,
  renderToReadableStream,
  setCurrentRequest,
  startWorkForPrerender,
  taintObjectReference,
  taintUniqueValue,
} from "../server/shared.mjs";

// Helper
async function streamToString(stream) {
  const reader = stream.getReader();
  const decoder = new TextDecoder();
  let result = "";
  while (true) {
    const { done, value } = await reader.read();
    if (done) break;
    result += decoder.decode(value, { stream: true });
  }
  return result;
}

describe("Server Shared Module - Additional Coverage", () => {
  describe("Current Request Context", () => {
    test("setCurrentRequest and getCurrentRequest", () => {
      expect(getCurrentRequest()).toBeNull();

      const mockRequest = { id: "test-request" };
      setCurrentRequest(mockRequest);
      expect(getCurrentRequest()).toBe(mockRequest);

      setCurrentRequest(null);
      expect(getCurrentRequest()).toBeNull();
    });
  });

  describe("emitHint", () => {
    test("should emit hint when request is FlightRequest", async () => {
      // Create a FlightRequest directly to test emitHint
      const request = new FlightRequest({ test: "data" });

      // Set up destination to capture output
      const chunks = [];
      request.destination = {
        enqueue: (chunk) => chunks.push(chunk),
        close: () => {},
        error: () => {},
      };
      request.flowing = true;

      // Emit a hint
      emitHint(request, "S", { href: "/styles.css", precedence: "default" });

      // writeChunk schedules flush via queueMicrotask
      await new Promise((r) => queueMicrotask(r));

      // Should have written a hint chunk
      expect(chunks.length).toBeGreaterThan(0);
      const output = new TextDecoder().decode(chunks[0]);
      expect(output).toContain("H"); // HINT row tag
      expect(output).toContain("styles.css");
    });

    test("should not emit hint when request is not FlightRequest", () => {
      // Passing a non-FlightRequest should be a no-op
      const fakeRequest = { emitHint: vi.fn() };
      emitHint(fakeRequest, "S", { href: "/styles.css" });
      // The fake emitHint should NOT be called because instanceof check fails
      expect(fakeRequest.emitHint).not.toHaveBeenCalled();
    });

    test("should emit multiple different hint types", async () => {
      const request = new FlightRequest({ test: "data" });
      const chunks = [];
      request.destination = {
        enqueue: (chunk) => chunks.push(chunk),
        close: () => {},
        error: () => {},
      };
      request.flowing = true;

      // Emit different hint types (stylesheet, preload, font)
      emitHint(request, "S", { href: "/styles.css", precedence: "default" });
      emitHint(request, "P", { href: "/script.js", as: "script" });
      emitHint(request, "F", { href: "/font.woff2", as: "font" });

      // writeChunk schedules flush via queueMicrotask
      await new Promise((r) => queueMicrotask(r));

      // All hints are coalesced into a single enqueue
      expect(chunks.length).toBeGreaterThan(0);
    });
  });

  describe("logToConsole", () => {
    test("should log to console and emit for replay", async () => {
      const request = new FlightRequest({ test: "data" });
      const chunks = [];
      request.destination = {
        enqueue: (chunk) => chunks.push(chunk),
        close: () => {},
        error: () => {},
      };
      request.flowing = true;

      // Mock console.log
      const originalLog = console.log;
      const logCalls = [];
      console.log = (...args) => logCalls.push(args);

      try {
        logToConsole(request, "log", ["test message", 123]);

        // Should have logged locally
        expect(logCalls).toHaveLength(1);
        expect(logCalls[0]).toEqual(["test message", 123]);

        // writeChunk schedules flush via queueMicrotask
        await new Promise((r) => queueMicrotask(r));

        // Should have emitted for replay
        expect(chunks.length).toBeGreaterThan(0);
        const output = new TextDecoder().decode(chunks[0]);
        expect(output).toContain("W"); // CONSOLE row tag
        expect(output).toContain("log");
      } finally {
        console.log = originalLog;
      }
    });

    test("should handle different console methods", async () => {
      const request = new FlightRequest({ test: "data" });
      const chunks = [];
      request.destination = {
        enqueue: (chunk) => chunks.push(chunk),
        close: () => {},
        error: () => {},
      };
      request.flowing = true;

      // Mock console methods
      const originalWarn = console.warn;
      const originalError = console.error;
      const warnCalls = [];
      const errorCalls = [];
      console.warn = (...args) => warnCalls.push(args);
      console.error = (...args) => errorCalls.push(args);

      try {
        logToConsole(request, "warn", ["warning!"]);
        logToConsole(request, "error", ["error!"]);

        // writeChunk schedules flush via queueMicrotask
        await new Promise((r) => queueMicrotask(r));

        expect(warnCalls).toHaveLength(1);
        expect(errorCalls).toHaveLength(1);
        // Chunks are coalesced into a single enqueue
        expect(chunks.length).toBeGreaterThan(0);
      } finally {
        console.warn = originalWarn;
        console.error = originalError;
      }
    });

    test("should not log when request is not FlightRequest", () => {
      const fakeRequest = { emitConsoleLog: vi.fn() };
      const originalLog = console.log;
      const logCalls = [];
      console.log = (...args) => logCalls.push(args);

      try {
        logToConsole(fakeRequest, "log", ["test"]);
        // Neither local log nor emitConsoleLog should be called

        expect(logCalls).toHaveLength(0);
        expect(fakeRequest.emitConsoleLog).not.toHaveBeenCalled();
      } finally {
        console.log = originalLog;
      }
    });
  });

  describe("FlightRequest direct tests", () => {
    test("should emit debug info", async () => {
      const request = new FlightRequest({ test: "data" });
      // Enable dev mode for this test
      request.isDev = true;
      const chunks = [];
      request.destination = {
        enqueue: (chunk) => chunks.push(chunk),
        close: () => {},
        error: () => {},
      };
      request.flowing = true;

      // Emit debug info (now takes id as first argument)
      const id = request.getNextChunkId();
      request.emitDebugInfo(id, { component: "TestComponent", line: 42 });

      await new Promise((r) => queueMicrotask(r));

      expect(chunks.length).toBeGreaterThan(0);
      const output = new TextDecoder().decode(chunks[0]);
      expect(output).toContain("D"); // DEBUG row tag
      expect(output).toContain("TestComponent");
    });

    test("should emit postpone marker", async () => {
      const request = new FlightRequest({ test: "data" });
      const chunks = [];
      request.destination = {
        enqueue: (chunk) => chunks.push(chunk),
        close: () => {},
        error: () => {},
      };
      request.flowing = true;

      // Emit postpone
      request.emitPostpone(1, "Waiting for data");

      await new Promise((r) => queueMicrotask(r));

      expect(chunks.length).toBeGreaterThan(0);
      const output = new TextDecoder().decode(chunks[0]);
      expect(output).toContain("P"); // POSTPONE row tag
    });

    test("should serialize console log with complex arguments", async () => {
      const request = new FlightRequest({ test: "data" });
      const chunks = [];
      request.destination = {
        enqueue: (chunk) => chunks.push(chunk),
        close: () => {},
        error: () => {},
      };
      request.flowing = true;

      // Mock console.log
      const originalLog = console.log;
      console.log = () => {};

      try {
        // Log with various arg types
        logToConsole(request, "log", [
          "message",
          123,
          { nested: "object" },
          [1, 2, 3],
          null,
          undefined,
        ]);

        await new Promise((r) => queueMicrotask(r));

        expect(chunks.length).toBeGreaterThan(0);
        // Find the console chunk
        const consoleChunk = chunks.find((c) => {
          const output = new TextDecoder().decode(c);
          return output.includes(":W");
        });
        expect(consoleChunk).toBeDefined();
        const output = new TextDecoder().decode(consoleChunk);
        expect(output).toContain("message");
      } finally {
        console.log = originalLog;
      }
    });

    test("should handle environmentName option", () => {
      const request = new FlightRequest(
        { test: "data" },
        { environmentName: "CustomEnv" }
      );
      expect(request.environmentName).toBe("CustomEnv");
    });

    test("should use default environmentName", () => {
      const request = new FlightRequest({ test: "data" });
      expect(request.environmentName).toBe("Server");
    });

    test("should handle filterStackFrame option", () => {
      const filterFn = (frame) => !frame.includes("node_modules");
      const request = new FlightRequest(
        { test: "data" },
        { filterStackFrame: filterFn }
      );
      expect(request.filterStackFrame).toBe(filterFn);
    });

    test("should safely close stream only once", () => {
      const request = new FlightRequest({ test: "data" });
      let closeCalls = 0;
      request.destination = {
        enqueue: () => {},
        close: () => closeCalls++,
        error: () => {},
      };
      request.flowing = true;

      // Close multiple times
      request.closeStream();
      request.closeStream();
      request.closeStream();

      // Should only close once
      expect(closeCalls).toBe(1);
      expect(request.closed).toBe(true);
    });

    test("should not close stream if aborted", () => {
      const request = new FlightRequest({ test: "data" });
      let closeCalls = 0;
      request.destination = {
        enqueue: () => {},
        close: () => closeCalls++,
        error: () => {},
      };
      request.flowing = true;
      request.aborted = true;

      request.closeStream();

      expect(closeCalls).toBe(0);
    });
  });

  describe("taintUniqueValue edge cases", () => {
    test("should throw for non-string/bigint values", () => {
      expect(() => taintUniqueValue("message", 123)).toThrow(
        "taintUniqueValue only accepts strings and bigints"
      );
      expect(() => taintUniqueValue("message", {})).toThrow(
        "taintUniqueValue only accepts strings and bigints"
      );
      expect(() => taintUniqueValue("message", null)).toThrow(
        "taintUniqueValue only accepts strings and bigints"
      );
    });
  });

  describe("startWorkForPrerender paths", () => {
    test("should call onAllReady when pendingChunks is 0", () => {
      let allReadyCalled = false;
      const request = new FlightRequest(
        { simple: "data" },
        {
          onAllReady: () => {
            allReadyCalled = true;
          },
        }
      );

      // Set up destination
      request.destination = {
        enqueue: () => {},
        close: () => {},
        error: () => {},
      };
      request.flowing = true;

      // Manually call startWorkForPrerender
      startWorkForPrerender(request);

      expect(allReadyCalled).toBe(true);
    });

    test("should not call onAllReady when pendingChunks > 0", () => {
      let allReadyCalled = false;
      const request = new FlightRequest(
        { simple: "data" },
        {
          onAllReady: () => {
            allReadyCalled = true;

          },
        }
      );

      request.destination = {
        enqueue: () => {},
        close: () => {},
        error: () => {},
      };
      request.flowing = true;

      // Simulate pending chunks
      request.pendingChunks = 1;

      startWorkForPrerender(request);

      // onAllReady should not be called because pendingChunks > 0
      expect(allReadyCalled).toBe(false);
    });

    test("should call onFatalError on serialization error", () => {
      let fatalErrorCalled = false;
      let capturedError = null;

      const badModel = {
        get value() {
          throw new Error("Serialization failed");
        },
      };

      const request = new FlightRequest(badModel, {
        onFatalError: (error) => {
          fatalErrorCalled = true;
          capturedError = error;
        },
      });

      request.destination = {
        enqueue: () => {},
        close: () => {},
        error: () => {},
      };
      request.flowing = true;

      startWorkForPrerender(request);

      expect(fatalErrorCalled).toBe(true);
      expect(capturedError?.message).toContain("Serialization failed");
    });

    test("should call onError when onFatalError is not provided", () => {
      let errorCalled = false;
      let capturedError = null;

      const badModel = {
        get value() {
          throw new Error("Error without fatal handler");
        },
      };

      const request = new FlightRequest(badModel, {
        onError: (error) => {
          errorCalled = true;
          capturedError = error;
        },
      });

      request.destination = {
        enqueue: () => {},
        close: () => {},
        error: () => {},
      };
      request.flowing = true;

      startWorkForPrerender(request);

      expect(errorCalled).toBe(true);
      expect(capturedError?.message).toContain("Error without fatal handler");
    });

    test("should handle error with neither onFatalError nor onError", () => {
      const badModel = {
        get value() {
          throw new Error("Unhandled error");
        },
      };

      const request = new FlightRequest(badModel, {});

      request.destination = {
        enqueue: () => {},
        close: () => {},
        error: () => {},
      };
      request.flowing = true;

      // Should not throw - error is silently caught
      expect(() => startWorkForPrerender(request)).not.toThrow();
    });
  });

  describe("taintObjectReference edge cases", () => {
    test("should throw for non-objects", () => {
      expect(() => taintObjectReference("message", "string")).toThrow(
        "taintObjectReference only accepts objects"
      );
      expect(() => taintObjectReference("message", 123)).toThrow(
        "taintObjectReference only accepts objects"
      );
      expect(() => taintObjectReference("message", null)).toThrow(
        "taintObjectReference only accepts objects"
      );
    });
  });

  describe("createClientModuleProxy edge cases", () => {
    test("should create proxy with various exports", () => {
      const moduleId = "/src/module.js";
      const proxy = createClientModuleProxy(moduleId);

      // Access default export
      const defaultExport = proxy.default;
      expect(defaultExport.$$typeof).toBe(Symbol.for("react.client.reference"));
      expect(defaultExport.$$id).toContain(moduleId);

      // Access named export
      const namedExport = proxy.MyComponent;
      expect(namedExport.$$typeof).toBe(Symbol.for("react.client.reference"));
      expect(namedExport.$$id).toContain(moduleId);
      expect(namedExport.$$id).toContain("MyComponent");
    });

    test("should cache client references on repeated access", () => {
      const moduleId = "/src/cached-module.js";
      const proxy = createClientModuleProxy(moduleId);

      // Access same export twice - should return cached reference
      const first = proxy.CachedComponent;
      const second = proxy.CachedComponent;

      expect(first).toBe(second); // Same reference from cache
      expect(first.$$id).toBe(`${moduleId}#CachedComponent`);
    });

    test("should return undefined for non-string keys (Symbol)", () => {
      const moduleId = "/src/symbol-test.js";
      const proxy = createClientModuleProxy(moduleId);

      // Access with Symbol key - should return undefined
      const symbolKey = Symbol("test");
      const result = proxy[symbolKey];
      expect(result).toBeUndefined();
    });

    test("should throw on set operation", () => {
      const moduleId = "/src/readonly.js";
      const proxy = createClientModuleProxy(moduleId);

      expect(() => {
        proxy.SomeExport = "value";
      }).toThrow("Cannot modify a client module proxy");
    });

    test("should implement has trap for string keys", () => {
      const moduleId = "/src/has-test.js";
      const proxy = createClientModuleProxy(moduleId);

      // 'in' operator uses has trap
      expect("SomeExport" in proxy).toBe(true);
      expect("AnyName" in proxy).toBe(true);
    });

    test("should return empty array for ownKeys", () => {
      const moduleId = "/src/keys-test.js";
      const proxy = createClientModuleProxy(moduleId);

      const keys = Object.keys(proxy);
      expect(keys).toEqual([]);
    });

    test("should implement getOwnPropertyDescriptor", () => {
      const moduleId = "/src/descriptor-test.js";
      const proxy = createClientModuleProxy(moduleId);

      const descriptor = Object.getOwnPropertyDescriptor(proxy, "MyExport");
      expect(descriptor).toBeDefined();
      expect(descriptor.configurable).toBe(true);
      expect(descriptor.enumerable).toBe(true);
      expect(descriptor.value.$$id).toBe(`${moduleId}#MyExport`);
    });

    test("should return undefined descriptor for non-string keys", () => {
      const moduleId = "/src/descriptor-symbol.js";
      const proxy = createClientModuleProxy(moduleId);

      const symbolKey = Symbol("test");
      const descriptor = Object.getOwnPropertyDescriptor(proxy, symbolKey);
      expect(descriptor).toBeUndefined();
    });
  });

  describe("decodeReplyFromAsyncIterable", () => {
    test("should decode JSON from async iterable", async () => {
      const encoder = new TextEncoder();
      const data = { message: "hello", count: 42 };
      const jsonString = JSON.stringify(data);

      async function* generateChunks() {
        yield encoder.encode(jsonString);
      }

      const result = await decodeReplyFromAsyncIterable(generateChunks());
      expect(result).toEqual(data);
    });

    test("should decode chunked JSON from async iterable", async () => {
      const encoder = new TextEncoder();
      const data = { message: "chunked data" };
      const jsonString = JSON.stringify(data);

      // Split into multiple chunks
      async function* generateChunks() {
        yield encoder.encode(jsonString.slice(0, 10));
        yield encoder.encode(jsonString.slice(10));
      }

      const result = await decodeReplyFromAsyncIterable(generateChunks());
      expect(result).toEqual(data);
    });

    test("should return raw string if not valid JSON", async () => {
      const encoder = new TextEncoder();
      const rawText = "not json content";

      async function* generateChunks() {
        yield encoder.encode(rawText);
      }

      const result = await decodeReplyFromAsyncIterable(generateChunks());
      expect(result).toBe(rawText);
    });

    test("should decode multipart form data", async () => {
      const encoder = new TextEncoder();
      const boundary = "----WebKitFormBoundary";
      const multipartData = [
        boundary,
        'Content-Disposition: form-data; name="field1"',
        "",
        "value1",
        boundary,
        'Content-Disposition: form-data; name="field2"',
        "",
        "value2",
        boundary + "--",
      ].join("\r\n");

      async function* generateChunks() {
        yield encoder.encode(multipartData);
      }

      const result = await decodeReplyFromAsyncIterable(generateChunks());
      expect(result.field1).toBe("value1");
      expect(result.field2).toBe("value2");
    });

    test("should decode multipart form data with $ACTION_REF", async () => {
      const encoder = new TextEncoder();
      const boundary = "----WebKitFormBoundary";
      const actionData = { action: "test", args: [1, 2, 3] };
      const multipartData = [
        boundary,
        'Content-Disposition: form-data; name="$ACTION_REF"',
        "",
        JSON.stringify(actionData),
        boundary + "--",
      ].join("\r\n");

      async function* generateChunks() {
        yield encoder.encode(multipartData);
      }

      const result = await decodeReplyFromAsyncIterable(generateChunks());
      expect(result).toEqual(actionData);
    });
  });

  describe("lookupServerReference and lookupClientReference", () => {
    test("should lookup registered server reference", () => {
      const fn = async function lookupTestAction() {
        return "result";
      };
      // registerServerReference(action, id, exportName) creates fullId as `${id}#${exportName}`
      const registered = registerServerReference(
        fn,
        "lookup-test-module",
        "action"
      );

      const found = lookupServerReference("lookup-test-module#action");
      expect(found).toBe(registered);
    });

    test("should return undefined for unknown server reference", () => {
      const found = lookupServerReference("unknown-module#action");
      expect(found).toBeUndefined();
    });

    test("should lookup registered client reference", () => {
      // registerClientReference(proxy, id, exportName) creates $$id as `${id}#${exportName}`
      const ref = registerClientReference(
        {},
        "lookup-client-module",
        "Component"
      );

      const found = lookupClientReference("lookup-client-module#Component");
      expect(found).toBe(ref);
    });

    test("should return undefined for unknown client reference", () => {
      const found = lookupClientReference("unknown-module#Component");
      expect(found).toBeUndefined();
    });
  });

  describe("registerServerReference with bound arguments", () => {
    test("should serialize bound args correctly", async () => {
      const fn = async function myAction(a, b) {
        return a + b;
      };
      const registered = registerServerReference(fn, "module#myAction");

      expect(registered.$$typeof).toBe(Symbol.for("react.server.reference"));
      expect(registered.$$id).toContain("module#myAction");
      // $$bound is null unless explicitly bound via .bind()
      expect(registered.$$bound).toBeNull();
    });
  });

  describe("registerClientReference", () => {
    test("should create client reference with module info", () => {
      const ref = registerClientReference({}, "module#export", {});
      expect(ref.$$typeof).toBe(Symbol.for("react.client.reference"));
    });
  });

  describe("Temporary Reference Set", () => {
    test("should track temporary references", () => {
      const tempRefs = createTemporaryReferenceSet();
      expect(tempRefs).toBeDefined();
      expect(
        tempRefs instanceof Map ||
          tempRefs instanceof Set ||
          typeof tempRefs === "object"
      ).toBe(true);
    });
  });

  describe("decodeAction", () => {
    test("should decode server action from FormData", async () => {
      // Create a FormData with action reference
      const formData = new FormData();
      formData.append("$ACTION_REF", "module#action");
      formData.append("$ACTION_ARGS", JSON.stringify(["arg1", "arg2"]));

      const action = await decodeAction(formData, {
        serverReferences: {
          "module#action": async (args) => ({ result: args }),
        },
      });

      // decodeAction should return the decoded action or data
      expect(action).toBeDefined();
    });

    test("should return null for non-FormData input", async () => {
      const result = await decodeAction("not formdata");
      expect(result).toBeNull();
    });

    test("should return null for FormData without $ACTION_ID", async () => {
      const formData = new FormData();
      formData.append("someField", "value");

      const result = await decodeAction(formData);
      expect(result).toBeNull();
    });

    test("should lookup action from registry first", async () => {
      const testAction = async () => "from registry";
      registerServerReference(testAction, "registry-test", "myAction");

      const formData = new FormData();
      formData.append("$ACTION_ID", "registry-test#myAction");

      const result = await decodeAction(formData);
      expect(result).toBeDefined();
      expect(result.$$id).toBe("registry-test#myAction");
    });

    test("should use moduleLoader.loadServerAction callback", async () => {
      const loadedAction = async () => "loaded";
      const formData = new FormData();
      formData.append("$ACTION_ID", "chunk-loader-test#action");

      const result = await decodeAction(formData, {
        moduleLoader: {
          loadServerAction: async (id) => {
            if (id === "chunk-loader-test#action") {
              return loadedAction;
            }
            return null;
          },
        },
      });

      expect(result).toBe(loadedAction);
    });

    test("should return null when moduleLoader returns non-function", async () => {
      const formData = new FormData();
      formData.append("$ACTION_ID", "chunk-loader-invalid#action");

      const result = await decodeAction(formData, {
        moduleLoader: {
          loadServerAction: async () => "not a function",
        },
      });

      expect(result).toBeNull();
    });

    test("should handle ESM module loading with string manifest", async () => {
      // ESM mode: actionId format is "filepath#exportName"
      const formData = new FormData();
      // Use a URL format that import() can handle
      formData.append("$ACTION_ID", "nonexistent-module.mjs#action");

      // With string manifest (ESM base path), it tries to load the module
      const result = await decodeAction(formData, "file:///tmp/base/");

      // Should return null if module fails to load
      expect(result).toBeNull();
    });

    test("should return null for ESM with invalid action ID format", async () => {
      const formData = new FormData();
      // No # separator
      formData.append("$ACTION_ID", "invalid-format");

      const result = await decodeAction(formData, "file:///tmp/base/");
      expect(result).toBeNull();
    });

    test("should return null for ESM when module has no matching export", async () => {
      // Register an action but try to access a different export
      const testAction = async () => "test";
      registerServerReference(testAction, "esm-module", "existingExport");

      const formData = new FormData();
      formData.append("$ACTION_ID", "other-module#nonExistentExport");

      const result = await decodeAction(formData, "file:///tmp/base/");
      expect(result).toBeNull();
    });

    test("should load action from ESM module successfully", async () => {
      const formData = new FormData();
      // Use actual test module path
      const testModulePath = new URL(
        "./test-action-module.mjs",
        import.meta.url
      ).href;
      // Remove the #export part to get the base
      const baseUrl = testModulePath.substring(
        0,
        testModulePath.lastIndexOf("/") + 1
      );
      const moduleName = "test-action-module.mjs";

      formData.append("$ACTION_ID", `${moduleName}#testAction`);

      const result = await decodeAction(formData, baseUrl);
      expect(typeof result).toBe("function");
      // Call the action to verify it works
      const actionResult = await result();
      expect(actionResult).toBe("action result");
    });

    test("should return null when ESM module export is not a function", async () => {
      const formData = new FormData();
      const testModulePath = new URL(
        "./test-action-module.mjs",
        import.meta.url
      ).href;
      const baseUrl = testModulePath.substring(
        0,
        testModulePath.lastIndexOf("/") + 1
      );
      const moduleName = "test-action-module.mjs";

      formData.append("$ACTION_ID", `${moduleName}#notAFunction`);

      const result = await decodeAction(formData, baseUrl);
      expect(result).toBeNull();
    });

    test("should handle file:// prefixed filepath in ESM mode", async () => {
      const formData = new FormData();
      const testModulePath = new URL(
        "./test-action-module.mjs",
        import.meta.url
      ).href;

      // Use file:// prefixed path directly
      formData.append("$ACTION_ID", `${testModulePath}#testAction`);

      // The base path doesn't matter when filepath already has file://
      const result = await decodeAction(formData, "file:///ignored/");
      expect(typeof result).toBe("function");
    });
  });

  describe("deserializeValue", () => {
    test("should pass through non-string values", () => {
      expect(deserializeValue(42)).toBe(42);
      expect(deserializeValue(true)).toBe(true);
      expect(deserializeValue(null)).toBe(null);
    });

    test("should pass through strings that don't start with $", () => {
      expect(deserializeValue("hello")).toBe("hello");
      expect(deserializeValue("normal string")).toBe("normal string");
    });

    test("should handle $$ prefix (unescape dollar sign)", () => {
      expect(deserializeValue("$$100")).toBe("$100");
      expect(deserializeValue("$$ escaped")).toBe("$ escaped");
    });

    test("should handle $undefined", () => {
      expect(deserializeValue("$undefined")).toBe(undefined);
    });

    test("should handle $NaN", () => {
      expect(Number.isNaN(deserializeValue("$NaN"))).toBe(true);
    });

    test("should handle $Infinity and $-Infinity", () => {
      expect(deserializeValue("$Infinity")).toBe(Infinity);
      expect(deserializeValue("$-Infinity")).toBe(-Infinity);
    });

    test("should handle $n prefix (BigInt)", () => {
      expect(deserializeValue("$n12345")).toBe(BigInt(12345));
      expect(deserializeValue("$n9007199254740993")).toBe(
        BigInt("9007199254740993")
      );
    });

    test("should handle $S prefix (Symbol)", () => {
      const result = deserializeValue("$SmySymbol");
      expect(result).toBe(Symbol.for("mySymbol"));
    });

    test("should handle $D prefix (Date)", () => {
      const dateStr = "2024-01-15T12:00:00.000Z";
      const result = deserializeValue(`$D${dateStr}`);
      expect(result).toBeInstanceOf(Date);
      expect(result.toISOString()).toBe(dateStr);
    });

    test("should handle $Q prefix (Map)", () => {
      const entries = JSON.stringify([
        ["key1", "value1"],
        ["key2", 42],
      ]);
      const result = deserializeValue(`$Q${entries}`);
      expect(result).toBeInstanceOf(Map);
      expect(result.get("key1")).toBe("value1");
      expect(result.get("key2")).toBe(42);
    });

    test("should handle $W prefix (Set)", () => {
      const items = JSON.stringify(["a", "b", "c"]);
      const result = deserializeValue(`$W${items}`);
      expect(result).toBeInstanceOf(Set);
      expect(result.has("a")).toBe(true);
      expect(result.has("b")).toBe(true);
      expect(result.has("c")).toBe(true);
    });

    test("should handle $l prefix (URL)", () => {
      const result = deserializeValue("$lhttps://example.com/path");
      expect(result).toBeInstanceOf(URL);
      expect(result.href).toBe("https://example.com/path");
    });

    test("should handle $U prefix (URLSearchParams)", () => {

      const entries = JSON.stringify([
        ["foo", "bar"],
        ["baz", "qux"],
      ]);
      const result = deserializeValue(`$U${entries}`);
      expect(result).toBeInstanceOf(URLSearchParams);
      expect(result.get("foo")).toBe("bar");
      expect(result.get("baz")).toBe("qux");
    });

    test("should handle $K prefix (FormData via partId)", () => {
      // Client encodes FormData entries under prefix "partId_" in the outer body
      const body = new FormData();
      body.set("0", '"$K1"');
      body.append("1_field1", "value1");
      body.append("1_field2", "value2");

      const result = deserializeValue("$K1", { body });
      expect(result).toBeInstanceOf(FormData);
      expect(result.get("field1")).toBe("value1");
      expect(result.get("field2")).toBe("value2");
    });

    test("should handle $K prefix with File in FormData body", () => {
      const body = new FormData();
      body.set("0", '"$K1"');
      const blob = new Blob(["test content"], { type: "text/plain" });
      body.append("1_file1", blob);

      const result = deserializeValue("$K1", { body });
      expect(result).toBeInstanceOf(FormData);
      expect(result.get("file1")).toBeInstanceOf(Blob);
    });

    test("should return empty FormData for $K without body", () => {
      const result = deserializeValue("$K1", {});
      expect(result).toBeInstanceOf(FormData);
    });

    test("should handle $h prefix with moduleLoader and FormData body", async () => {
      const mockAction = () => "loaded action";
      const body = new FormData();
      body.set("1", JSON.stringify({ id: "some-action-id", bound: null }));
      const result = await deserializeValue("$h1", {
        body,
        moduleLoader: {
          loadServerAction: async (id) => {
            if (id === "some-action-id") return mockAction;
            return null;
          },
        },
      });
      expect(result).toBe(mockAction);
    });

    test("should throw error for $h without loader configured", () => {
      const body = new FormData();
      body.set("1", JSON.stringify({ id: "some-action-id", bound: null }));
      expect(() => deserializeValue("$h1", { body })).toThrow(
        "No server action loader configured"
      );
    });

    test("should recursively deserialize arrays", () => {
      const result = deserializeValue(["$$money", "normal", 42], {});
      expect(result).toEqual(["$money", "normal", 42]);
    });

    test("should recursively deserialize objects", () => {
      const result = deserializeValue(
        {
          price: "$$99.99",
          name: "item",
          count: 5,
        },
        {}
      );
      expect(result).toEqual({
        price: "$99.99",
        name: "item",
        count: 5,
      });
    });

    test("should handle nested structures", () => {
      const result = deserializeValue(
        {
          items: [
            { price: "$$10", name: "item1" },
            { price: "$$20", name: "item2" },
          ],
          total: "$$30",
        },
        {}
      );
      expect(result).toEqual({
        items: [
          { price: "$10", name: "item1" },
          { price: "$20", name: "item2" },
        ],
        total: "$30",
      });
    });
  });

  describe("decodeFormState", () => {
    test("should decode form state", async () => {
      const state = { value: "test", count: 42 };
      const formData = new FormData();

      const decoded = await decodeFormState(state, formData);
      expect(decoded).toBeDefined();
    });
  });

  describe("prerender", () => {
    test("should return prelude stream", async () => {
      const data = { prerendered: true, items: [1, 2, 3] };
      const result = await prerender(data);

      expect(result).toHaveProperty("prelude");
      expect(result.prelude).toBeInstanceOf(ReadableStream);
    });

    test("should handle complex nested data", async () => {
      const data = {
        users: [
          { id: 1, name: "Alice", roles: new Set(["admin", "user"]) },
          { id: 2, name: "Bob", metadata: new Map([["key", "value"]]) },
        ],
        timestamp: new Date("2024-01-01"),
        config: {
          deep: {
            nested: {
              value: BigInt(12345678901234567890n),
            },
          },
        },
      };

      const result = await prerender(data);
      const output = await streamToString(result.prelude);
      expect(output).toContain("users");
      expect(output).toContain("Alice");
    });

    test("should resolve when prerender completes (exercises onAllReady)", async () => {
      const data = { simple: "data" };

      // prerender internally uses onAllReady to resolve
      const result = await prerender(data);

      expect(result).toHaveProperty("prelude");
      expect(result.prelude).toBeInstanceOf(ReadableStream);
    });

    test("should reject on serialization errors (exercises onFatalError)", async () => {
      // Create an object that throws during serialization
      const badObject = {
        get value() {
          throw new Error("Serialization error");
        },
      };

      // prerender internally uses onFatalError to reject
      await expect(prerender(badObject)).rejects.toThrow("Serialization error");
    });

    test("should prerender with empty object", async () => {
      const result = await prerender({});
      expect(result).toHaveProperty("prelude");
      const output = await streamToString(result.prelude);
      expect(output).toContain("0:");
    });

    test("should prerender with null model", async () => {
      const result = await prerender(null);
      expect(result).toHaveProperty("prelude");
      const output = await streamToString(result.prelude);
      expect(output).toContain("null");
    });

    test("should prerender with primitive string", async () => {
      const result = await prerender("hello world");
      expect(result).toHaveProperty("prelude");
      const output = await streamToString(result.prelude);
      expect(output).toContain("hello world");
    });

    test("should prerender with array", async () => {
      const result = await prerender([1, 2, 3, "test"]);
      expect(result).toHaveProperty("prelude");
      const output = await streamToString(result.prelude);
      expect(output).toContain("test");
    });

    test("should prerender and consume prelude stream", async () => {
      const data = { message: "consume test", count: 42 };
      const { prelude } = await prerender(data);

      // Consume the stream
      const reader = prelude.getReader();
      const chunks = [];
      while (true) {
        const { done, value } = await reader.read();
        if (done) break;
        chunks.push(value);
      }

      expect(chunks.length).toBeGreaterThan(0);
      const fullOutput = new TextDecoder().decode(
        new Uint8Array(chunks.flatMap((c) => Array.from(c)))
      );
      expect(fullOutput).toContain("consume test");
    });
  });

  describe("Circular reference handling", () => {
    test("should handle circular array references", async () => {
      const arr = [1, 2, 3];
      arr.push(arr);

      const stream = renderToReadableStream(arr);
      const output = await streamToString(stream);
      expect(output).toContain("1");
    });
  });

  describe("Special number serialization", () => {
    test("should handle -0", async () => {
      const stream = renderToReadableStream(-0);
      const result = await createFromReadableStream(stream);
      expect(Object.is(result, -0)).toBe(true);
    });

    test("should handle very large numbers", async () => {
      const large = Number.MAX_SAFE_INTEGER + 2; // Larger than MAX_SAFE_INTEGER
      const stream = renderToReadableStream(large);
      const result = await createFromReadableStream(stream);
      expect(result).toBe(large);
    });
  });

  describe("Unicode and special strings", () => {
    test("should handle emoji", async () => {
      const data = { emoji: "👨‍👩‍👧‍👦🎉🚀" };
      const stream = renderToReadableStream(data);
      const result = await createFromReadableStream(stream);
      expect(result.emoji).toBe("👨‍👩‍👧‍👦🎉🚀");
    });

    test("should handle various unicode", async () => {
      const data = {
        arabic: "مرحبا",
        chinese: "你好世界",
        japanese: "こんにちは",
        korean: "안녕하세요",
        thai: "สวัสดี",
        special: "∀x∈ℝ: x² ≥ 0",
      };
      const stream = renderToReadableStream(data);
      const result = await createFromReadableStream(stream);
      expect(result).toEqual(data);
    });
  });

  describe("Empty and null containers", () => {
    test("should handle empty Map", async () => {
      const stream = renderToReadableStream(new Map());
      const result = await createFromReadableStream(stream);
      expect(result).toBeInstanceOf(Map);
      expect(result.size).toBe(0);
    });

    test("should handle empty Set", async () => {
      const stream = renderToReadableStream(new Set());
      const result = await createFromReadableStream(stream);
      expect(result).toBeInstanceOf(Set);
      expect(result.size).toBe(0);
    });

    test("should handle empty array", async () => {
      const stream = renderToReadableStream([]);
      const result = await createFromReadableStream(stream);
      expect(result).toEqual([]);
    });

    test("should handle empty object", async () => {
      const stream = renderToReadableStream({});
      const result = await createFromReadableStream(stream);
      expect(result).toEqual({});
    });
  });
});

describe("Client Shared Module - Additional Coverage", () => {
  describe("encodeReply with complex types", () => {
    test("should encode Map in reply", async () => {
      const data = new Map([
        ["key1", "value1"],
        ["key2", { nested: true }],
      ]);

      const encoded = await encodeReply(data);
      expect(encoded).toBeDefined();
    });

    test("should encode Set in reply", async () => {
      const data = new Set([1, 2, 3, "string", { obj: true }]);

      const encoded = await encodeReply(data);
      expect(encoded).toBeDefined();
    });

    test("should encode Date in reply", async () => {
      const data = { date: new Date("2024-06-15T12:00:00Z") };

      const encoded = await encodeReply(data);
      expect(encoded).toBeDefined();
    });

    test("should encode nested structures", async () => {
      const data = {
        array: [1, 2, { nested: [3, 4] }],
        map: new Map([["a", new Set([1, 2])]]),
      };

      const encoded = await encodeReply(data);
      expect(encoded).toBeDefined();
    });

    test("should encode FormData", async () => {
      const formData = new FormData();
      formData.append("field1", "value1");
      formData.append("field2", "value2");

      // encodeReply returns a string for simple data
      const encoded = await encodeReply({ wrapper: "form" });
      expect(typeof encoded === "string" || encoded instanceof FormData).toBe(
        true
      );
    });

    test("should round-trip FormData with Blob", async () => {
      const formData = new FormData();
      formData.append("name", "test");
      const blob = new Blob(["hello"], { type: "text/plain" });
      formData.append("file", blob, "hello.txt");

      const encoded = await encodeReply(formData);
      // encoded should be a FormData because it has a Blob
      expect(encoded).toBeInstanceOf(FormData);

      const decoded = await decodeReply(encoded);

      expect(decoded).toBeInstanceOf(FormData);
      expect(decoded.get("name")).toBe("test");
      const decodedBlob = decoded.get("file");
      expect(decodedBlob).toBeInstanceOf(Blob);
      expect(await decodedBlob.text()).toBe("hello");
    });

    test("should round-trip nested object with Blob", async () => {
      const blob = new Blob(["hello"], { type: "text/plain" });
      const data = {
        info: "test",
        file: blob,
      };

      const encoded = await encodeReply(data);
      expect(encoded).toBeInstanceOf(FormData);

      // The Blob is stored as a direct FormData part under its path key,
      // and `$K<path>` resolves back to the original Blob on decode.
      const decoded = await decodeReply(encoded);
      expect(decoded.info).toBe("test");
      expect(decoded.file).toBeInstanceOf(Blob);
      expect(await decoded.file.text()).toBe("hello");
    });
  });

  describe("createServerReference edge cases", () => {
    test("should handle empty args", async () => {
      const callServer = vi.fn().mockResolvedValue("result");
      const action = createServerReference("module#noArgs", callServer);

      await action();
      expect(callServer).toHaveBeenCalledWith("module#noArgs", []);
    });

    test("should handle many args", async () => {
      const callServer = vi.fn().mockResolvedValue("result");
      const action = createServerReference("module#manyArgs", callServer);

      await action(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
      expect(callServer).toHaveBeenCalledWith(
        "module#manyArgs",
        [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
      );
    });

    test("should handle complex arg types", async () => {
      const callServer = vi.fn().mockResolvedValue("result");
      const action = createServerReference("module#complexArgs", callServer);

      const date = new Date();
      const map = new Map([["k", "v"]]);

      await action({ nested: { deep: true } }, [1, 2, 3], date, map);
      expect(callServer).toHaveBeenCalled();
    });

    test("bound action should accumulate args", async () => {
      const callServer = vi.fn().mockResolvedValue("result");
      const action = createServerReference("module#bound", callServer);

      const bound1 = action.bind(null, "a");
      const bound2 = bound1.bind(null, "b");

      await bound2("c", "d");
      // Note: each .bind creates a new reference, not accumulative
      // The second bind should have "b" as its bound arg
    });
  });

  describe("decodeReply with various inputs", () => {
    test("should decode JSON string", async () => {
      const input = JSON.stringify({ test: "value", num: 42 });
      const result = await decodeReply(input);
      expect(result).toEqual({ test: "value", num: 42 });
    });

    test("should handle null input", async () => {
      const result = await decodeReply("null");
      expect(result).toBeNull();
    });

    test("should handle array input", async () => {
      const result = await decodeReply("[1, 2, 3]");
      expect(result).toEqual([1, 2, 3]);
    });
  });
});

describe("Serialization Edge Cases", () => {
  describe("Deeply nested structures", () => {
    test("should handle 10 levels deep", async () => {
      let obj = { value: "bottom" };
      for (let i = 0; i < 10; i++) {
        obj = { level: i, child: obj };
      }

      const stream = renderToReadableStream(obj);
      const result = await createFromReadableStream(stream);

      // Navigate to bottom
      let current = result;
      for (let i = 9; i >= 0; i--) {
        expect(current.level).toBe(i);
        current = current.child;
      }
      expect(current.value).toBe("bottom");
    });
  });

  describe("Large arrays", () => {
    test("should handle array with 1000 elements", async () => {
      const arr = Array.from({ length: 1000 }, (_, i) => ({
        index: i,
        value: `item-${i}`,
      }));

      const stream = renderToReadableStream(arr);
      const result = await createFromReadableStream(stream);

      expect(result.length).toBe(1000);
      expect(result[0].index).toBe(0);
      expect(result[999].index).toBe(999);
    });
  });

  describe("Mixed type arrays", () => {
    test("should handle arrays with mixed types", async () => {
      const arr = [
        1,
        "string",
        true,
        null,
        undefined,
        { obj: true },
        [1, 2, 3],
        new Date("2024-01-01"),
        BigInt(123),
        new Map([["a", 1]]),
        new Set([1, 2, 3]),
        Symbol.for("test"),
        /regex/gi,
      ];

      const stream = renderToReadableStream(arr);
      const result = await createFromReadableStream(stream);

      expect(result[0]).toBe(1);
      expect(result[1]).toBe("string");
      expect(result[2]).toBe(true);
      expect(result[3]).toBeNull();
      expect(result[4]).toBeUndefined();
      expect(result[5]).toEqual({ obj: true });
      expect(result[6]).toEqual([1, 2, 3]);
      expect(result[7]).toBeInstanceOf(Date);
      expect(result[8]).toBe(BigInt(123));
      expect(result[9]).toBeInstanceOf(Map);
      expect(result[10]).toBeInstanceOf(Set);
      expect(result[11]).toBe(Symbol.for("test"));
      expect(result[12]).toBeInstanceOf(RegExp);
    });
  });

  describe("Object with special property names", () => {
    test("should handle $-prefixed properties", async () => {
      const obj = {
        $ref: "reference",
        $$special: "double-dollar",
        $1: "numeric",
        normal: "value",
      };

      const stream = renderToReadableStream(obj);
      const result = await createFromReadableStream(stream);

      // These should be escaped and handled correctly
      expect(result.normal).toBe("value");
    });

    test("should handle numeric string keys", async () => {
      const obj = {
        0: "zero",
        1: "one",
        123: "numbers",
      };

      const stream = renderToReadableStream(obj);
      const result = await createFromReadableStream(stream);

      expect(result["0"]).toBe("zero");
      expect(result["123"]).toBe("numbers");
    });
  });
});

describe("Additional Coverage - Client Streaming and Binary", () => {
  describe("createFromFetch", () => {
    const { createFromFetch } = require("../client/shared.mjs");

    test("should create from fetch response", async () => {
      const data = { message: "from fetch" };
      const stream = renderToReadableStream(data);

      // Mock fetch Response
      const mockResponse = {
        ok: true,
        status: 200,
        statusText: "OK",
        body: stream,
      };

      const result = await createFromFetch(Promise.resolve(mockResponse));
      expect(result).toEqual(data);
    });

    test("should throw on HTTP error response", async () => {
      const mockResponse = {
        ok: false,
        status: 404,
        statusText: "Not Found",
        body: null,
      };

      await expect(
        createFromFetch(Promise.resolve(mockResponse))
      ).rejects.toThrow("HTTP 404: Not Found");
    });

    test("should throw when response has no body", async () => {
      const mockResponse = {
        ok: true,
        status: 200,
        statusText: "OK",
        body: null,
      };

      await expect(
        createFromFetch(Promise.resolve(mockResponse))
      ).rejects.toThrow("Response has no body");
    });
  });

  describe("encodeReply with FormData and Files", () => {
    test("should encode File in FormData", async () => {
      // Skip if File is not defined (Node.js without polyfill)

      if (typeof File === "undefined") {
        return;
      }

      const file = new File(["content"], "test.txt", { type: "text/plain" });
      const result = await encodeReply({ file });

      expect(result).toBeInstanceOf(FormData);
    });

    test("should encode Blob in FormData", async () => {
      const blob = new Blob(["content"], { type: "text/plain" });
      const result = await encodeReply({ blob });

      expect(result).toBeInstanceOf(FormData);
    });

    test("should encode nested File in array", async () => {
      if (typeof File === "undefined") {
        return;
      }

      const file = new File(["content"], "test.txt");
      const result = await encodeReply({ items: [file, "text"] });

      expect(result).toBeInstanceOf(FormData);
    });

    test("should return FormData when input is FormData without files", async () => {
      const formData = new FormData();
      formData.set("name", "test");
      formData.set("value", "123");
      const result = await encodeReply(formData);

      expect(result).toBeInstanceOf(FormData);
      expect(result.has("0")).toBe(true);
    });

    test("should return FormData when input object contains a FormData", async () => {
      const formData = new FormData();
      formData.set("name", "test");
      const result = await encodeReply({
        __react_server_function_args__: formData,
        __react_server_remote_props__: "{}",
      });

      expect(result).toBeInstanceOf(FormData);
      expect(result.has("0")).toBe(true);
    });
  });

  describe("Server error rows", () => {
    test("should handle error row with digest", async () => {
      const wire =
        '0:E{"message":"Test error","stack":"Error: Test","digest":"abc123"}\n';
      const stream = new ReadableStream({
        start(controller) {
          controller.enqueue(new TextEncoder().encode(wire));
          controller.close();
        },
      });

      // Error rows at id=0 resolve with an ErrorThrower element
      const result = await createFromReadableStream(stream);
      expect(result.type.displayName).toBe("FlightError");
      expect(() => result.type()).toThrow("Test error");
    });
  });

  describe("Postpone (PPR) rows", () => {
    test("should handle postpone row", async () => {
      const wire = '0:P"deferred-reason"\n';
      const stream = new ReadableStream({
        start(controller) {
          controller.enqueue(new TextEncoder().encode(wire));
          controller.close();
        },
      });

      try {
        await createFromReadableStream(stream);
      } catch (error) {
        expect(error.message).toContain("Postponed");
        expect(error.$$typeof).toBe(Symbol.for("react.postpone"));
      }
    });

    test("should call onPostpone callback for postponed promises", async () => {
      const postponeReasons = [];
      // Create a postpone error
      const postponeError = new Error("Postponed: deferred content");
      postponeError.$$typeof = Symbol.for("react.postpone");
      postponeError.reason = "deferred content";

      // Render data that includes a promise that rejects with postpone
      const postponedPromise = Promise.reject(postponeError);
      // Prevent unhandled rejection
      postponedPromise.catch(() => {});

      const stream = renderToReadableStream(
        { data: postponedPromise },
        {
          onPostpone: (reason) => postponeReasons.push(reason),
        }
      );

      // Consume the stream
      await streamToString(stream);

      // The onPostpone callback should have been called
      expect(postponeReasons.length).toBeGreaterThan(0);
      expect(postponeReasons[0]).toBe("deferred content");
    });

    test("should emit postpone row and close stream when no more pending chunks", async () => {
      const postponeError = new Error("Postponed: single chunk");
      postponeError.$$typeof = Symbol.for("react.postpone");
      postponeError.reason = "single chunk";

      // Single postponed promise is the only pending work
      const postponedPromise = Promise.reject(postponeError);
      postponedPromise.catch(() => {});

      const stream = renderToReadableStream(postponedPromise, {
        onPostpone: () => {},
      });

      const output = await streamToString(stream);
      // Should contain a postpone row
      expect(output).toContain(":P");
    });
  });

  describe("Hint rows", () => {
    test("should process hint rows without error", async () => {
      // Hint row followed by actual data
      const wire = '1:H{"chunks":["chunk1"]}\n0:{"message":"data"}\n';
      const stream = new ReadableStream({
        start(controller) {
          controller.enqueue(new TextEncoder().encode(wire));
          controller.close();
        },
      });

      const result = await createFromReadableStream(stream);
      expect(result.message).toBe("data");
    });
  });

  describe("Debug info rows", () => {
    test("should process debug info with callback", async () => {
      const debugInfos = [];
      const wire = '1:D{"name":"Component"}\n0:{"data":"test"}\n';
      const stream = new ReadableStream({
        start(controller) {
          controller.enqueue(new TextEncoder().encode(wire));
          controller.close();
        },
      });

      const result = await createFromReadableStream(stream, {
        onDebugInfo: (id, info) => debugInfos.push({ id, info }),
      });

      expect(result.data).toBe("test");
      expect(debugInfos.length).toBe(1);
      expect(debugInfos[0].info.name).toBe("Component");
    });
  });

  describe("Console replay rows", () => {
    test("should replay console.log", async () => {
      const originalLog = console.log;
      const logs = [];
      console.log = (...args) => logs.push(args);

      try {
        const wire =
          '1:W{"method":"log","args":["Hello","World"],"env":"Server"}\n0:"done"\n';
        const stream = new ReadableStream({
          start(controller) {
            controller.enqueue(new TextEncoder().encode(wire));
            controller.close();
          },
        });

        await createFromReadableStream(stream);
        expect(logs.some((l) => l.includes("[Server]"))).toBe(true);
      } finally {
        console.log = originalLog;
      }
    });
  });

  describe("Global timestamp row", () => {
    test("should handle React timestamp row", async () => {
      // React sends a timestamp row with format :N<timestamp>
      const wire = ':N1234567890.123\n0:{"data":"test"}\n';
      const stream = new ReadableStream({
        start(controller) {