return runtime;

}

function firstCallArg(mock: ReturnType<typeof vi.fn>): unknown {

return mock.mock.calls[0]?.[0];

}

describe("createChannelApprovalHandlerFromCapability", () => {

it("returns null when the capability does not expose a native runtime", async () => {

await expect(

await approvalRuntime.stop();

expect(unbindPending).toHaveBeenCalledOnce();

const stopUnbind = unbindPending.mock.calls.at(0)?.[0];

const stopUnbind = firstCallArg(unbindPending) as

| { request?: unknown; approvalKind?: string }

| undefined;

expect(stopUnbind?.request).toBe(request);

expect(stopUnbind?.approvalKind).toBe("plugin");

});

} as never);

expect(unbindPending).toHaveBeenCalledTimes(1);

const unbind = unbindPending.mock.calls.at(0)?.[0];

const unbind = firstCallArg(unbindPending) as

| { entry?: unknown; binding?: unknown; request?: unknown }

| undefined;

expect(unbind?.entry).toEqual({ messageId: "1" });

expect(unbind?.binding).toEqual({ bindingId: "bound-1" });

expect(unbind?.request).toBe(request);

expect(unbindPending).toHaveBeenCalledTimes(2);

expect(buildResolvedResult).toHaveBeenCalledTimes(1);

expect(buildResolvedResult.mock.calls.at(0)?.[0]?.entry).toEqual({ messageId: "2" });

const resolvedPayload = firstCallArg(buildResolvedResult) as { entry?: unknown } | undefined;

expect(resolvedPayload?.entry).toEqual({ messageId: "2" });

});

it("continues stop-time unbind cleanup when one binding throws", async () => {