| undefined;

}

function responseErrorMessage(error: unknown): string {

if (error instanceof Error) {

return error.message;

}

if (error && typeof error === "object") {

const message = (error as { message?: unknown }).message;

if (typeof message === "string") {

return message;

}

return JSON.stringify(error);

}

return String(error);

}

function lastBroadcastPayload(context: ChatContext): Record<string, any> | undefined {

const chatCall = (context.broadcast as unknown as ReturnType<typeof vi.fn>).mock.calls.at(-1);

expect(chatCall?.[0]).toBe("chat");

).toBe(1);

});

const chatCall = (params.context.broadcast as unknown as ReturnType<typeof vi.fn>).mock.calls[0];

const chatCall = (params.context.broadcast as unknown as ReturnType<typeof vi.fn>).mock.calls.at(

0,

);

expect(chatCall?.[0]).toBe("chat");

return chatCall?.[1];

}

// so the client retries instead of treating it as a bad request.

expect(mockState.lastDispatchCtx).toBeUndefined();

expect(respond).toHaveBeenCalledTimes(1);

const [ok, payload, error] = respond.mock.calls[0] ?? [];

const [ok, payload, error] = lastRespondCall(respond) ?? [];

expect(ok).toBe(false);

expect(payload).toBeUndefined();

expect(error?.code).toBe(ErrorCodes.UNAVAILABLE);

expect(error?.message ?? String(error)).toMatch(/ENOSPC|non-image attachments/i);

const unavailableLogCall = (context.logGateway.error as unknown as ReturnType<typeof vi.fn>)

.mock.calls[0] as [string, Record<string, string>] | undefined;

expect(responseErrorMessage(error)).toMatch(/ENOSPC|non-image attachments/i);

const unavailableLogCall = (

context.logGateway.error as unknown as ReturnType<typeof vi.fn>

).mock.calls.at(0) as [string, Record<string, string>] | undefined;

expect(unavailableLogCall?.[0]).toBe("chat.send attachment parse/stage failed");

expect(unavailableLogCall?.[1].consoleMessage).toContain(

"chat.send attachment parse/stage failed: MediaOffloadError",

expect(mockState.lastDispatchCtx).toBeUndefined();

expect(respond).toHaveBeenCalledTimes(1);

const [ok, payload, error] = respond.mock.calls[0] ?? [];

const [ok, payload, error] = lastRespondCall(respond) ?? [];

expect(ok).toBe(false);

expect(payload).toBeUndefined();

expect(error?.code).toBe(ErrorCodes.UNAVAILABLE);

expect(error?.message ?? String(error)).toMatch(/staging incomplete/i);

expect(responseErrorMessage(error)).toMatch(/staging incomplete/i);

// Both media-store entries are cleaned up before the 5xx surfaces.

expect(mockState.deleteMediaBufferCalls.map((c) => c.id).toSorted()).toEqual([

"saved-media",

expect(mockState.lastDispatchCtx).toBeUndefined();

expect(respond).toHaveBeenCalledTimes(1);

const [ok, payload, error] = respond.mock.calls[0] ?? [];

const [ok, payload, error] = lastRespondCall(respond) ?? [];

expect(ok).toBe(false);

expect(payload).toBeUndefined();

// 4xx, not 5xx — retrying a file that exceeds the staging cap cannot

// succeed, so the failure must be surfaced as a client-side rejection.

expect(error?.code).toBe(ErrorCodes.INVALID_REQUEST);

expect(error?.message ?? String(error)).toMatch(/sandbox staging limit/i);

expect(responseErrorMessage(error)).toMatch(/sandbox staging limit/i);

// Orphaned media-store entries are cleaned up before the 4xx surfaces.

expect(mockState.deleteMediaBufferCalls).toEqual([{ id: "saved-media", subdir: "inbound" }]);

});