it("ensureContextEnginesInitialized() is idempotent and registers legacy", async () => {

const { ensureContextEnginesInitialized } = await import("./init.js");

expect(() => ensureContextEnginesInitialized()).not.toThrow();

expect(() => ensureContextEnginesInitialized()).not.toThrow();

expect(ensureContextEnginesInitialized()).toBeUndefined();

expect(ensureContextEnginesInitialized()).toBeUndefined();

const ids = listContextEngineIds();

expect(ids).toContain("legacy");

onConnectError,

});

// Should not throw

expect(() => client.start()).not.toThrow();

expect(client.start()).toBeUndefined();

expectSecurityConnectError(onConnectError);

expect(wsInstances.length).toBe(0); // No WebSocket created

const client = createClientWithIdentity("dev-2", onClose);

client.start();

expect(() => {

getLatestWs().emitClose(1008, "unauthorized: device token mismatch");

}).not.toThrow();

expect(getLatestWs().emitClose(1008, "unauthorized: device token mismatch")).toBeUndefined();

expect(logDebugMock).toHaveBeenCalledWith(

expect.stringContaining("failed clearing stale device-auth token"),

});

try {

expect(() => client.start()).not.toThrow();

expect(client.start()).toBeUndefined();

await connected;

expect(onConnectError).not.toHaveBeenCalled();

} finally {

expect(() => createSession("conn-1")).toThrow(

"Too many active realtime relay sessions for this connection",

);

expect(() => createSession("conn-2")).not.toThrow();

expect(createSession("conn-2")).toBeDefined();

});

});

enableConsoleCapture();

const epipe = new Error("write EPIPE") as NodeJS.ErrnoException;

epipe.code = "EPIPE";

expect(() => stream.emit("error", epipe)).not.toThrow();

expect(stream.emit("error", epipe)).toBe(true);

});

it("rethrows non-EPIPE errors on stdout", () => {

const unsubscribeNoisy = onSessionLifecycleEvent(noisy.listener);

const unsubscribeHealthy = onSessionLifecycleEvent(healthy.listener);

expect(() =>

expect(

emitSessionLifecycleEvent({

sessionKey: "agent:main:main",

reason: "resumed",

}),

).not.toThrow();

).toBeUndefined();

expect(noisy.calls).toHaveLength(1);

expect(healthy.calls).toHaveLength(1);