index: number,

) {

const call = mock.mock.calls[index] as unknown[] | undefined;

expect(call).toBeDefined();

if (!call) {

throw new Error(`missing reaction call ${index + 1}`);

}

function expectPreviewEditContent(content: string) {

const call = editMessageDiscord.mock.calls[0] as unknown[] | undefined;

expect(call).toBeDefined();

if (!call) {

throw new Error("missing preview edit call");

}

const resolveCall = discordTargetMocks.resolveDiscordTargetChannelId.mock.calls[0] as

| unknown[]

| undefined;

expect(resolveCall).toBeDefined();

if (!resolveCall) {

throw new Error("missing Discord target resolve call");

}

function callArg(mock: unknown, callIndex: number, argIndex: number, label: string) {

const calls = (mock as { mock?: { calls?: Array<Array<unknown>> } }).mock?.calls ?? [];

const call = calls.at(callIndex);

expect(call, label).toBeDefined();

return call?.[argIndex];

if (!call) {

throw new Error(`Expected ${label}`);

}

return call[argIndex];

}

function fetchParams(): Record<string, unknown> {

target: unknown,

expected: { kind: string; id: string; normalized?: string },

): void {

expect(target).toBeDefined();

expect(typeof target).toBe("object");

expect(target).not.toBeNull();

if (!target || typeof target !== "object") {

throw new Error("Expected target record");

}

const actual = target as Record<string, unknown>;

expect(actual.kind).toBe(expected.kind);

expect(actual.id).toBe(expected.id);

);

})?.[0] as { value?: { status?: unknown } } | undefined;

expect(activity).toBeDefined();

if (!activity) {

throw new Error("Expected invokeResponse activity");

}

if (status !== undefined) {

expect(activity?.value?.status).toBe(status);

expect(activity.value?.status).toBe(status);

}

}

function expectLogFields(logFn: unknown, message: string, fields: Record<string, unknown>): void {

const calls = (logFn as { mock?: { calls?: Array<[unknown, unknown?]> } }).mock?.calls;

expect(calls).toBeDefined();

const call = calls?.find(([text]) => text === message);

expect(call).toBeDefined();

const meta = call?.[1] as Record<string, unknown> | undefined;

expect(meta).toBeDefined();

if (!calls) {

throw new Error("Expected log mock calls");

}

const call = calls.find(([text]) => text === message);

if (!call) {

throw new Error(`Expected log message: ${message}`);

}

const meta = call[1] as Record<string, unknown> | undefined;

if (!meta) {

throw new Error(`Expected log metadata for: ${message}`);

}

for (const [key, value] of Object.entries(fields)) {

expect(meta?.[key]).toEqual(value);

expect(meta[key]).toEqual(value);

}

}

mediaUrl?: string;

} {

const options = call?.[2];

expect(options).toBeDefined();

if (!options) {

throw new Error("Expected Slack send options");

}

return options as {

blocks?: Array<{

block_id?: string;